
Ask HN: Which tools have made you a much better programmer? - karamazov
Getting better at coding is usually a long, slow process of study and practice. However, sometimes I run into something that&#x27;s easy to understand and, once I&#x27;m using it, feels like I&#x27;ve leveled up.<p>A few personal examples are: 
* version control - specifically, reading up on git and understanding the more complex commands 
* debuggers 
* flame graphs for performance debugging 
* good code search<p>What have you added to your workflow that&#x27;s made you much more productive?
======
Jeaye
\- GNU/Linux + i3wm; complete control over my programming environment.

\- bash + GNU coreutils; seriously, take the time to be able to write helpful
bash scripts which can run basically anywhere.

\- git; use it even when you're not pushing to a remote. Add helpful aliases
for everyday commands. Build a good mental model of commits and branches to
help you through tough merges. ( my ~/.gitconfig:
[https://gist.github.com/jeaye/950300ff8120950814879a46b796b3...](https://gist.github.com/jeaye/950300ff8120950814879a46b796b3c7)
)

\- Regex; combined with bash and your GNU tools, a _lot_ can be done.

\- Vim; modal editing and vi-like navigation can blow open your mind. Explore
the existing plugins to accomplish everything you want to be able to do. It's
all there. ( my ~/.vimrc:
[https://github.com/jeaye/vimrc](https://github.com/jeaye/vimrc) )

\- Functional programming; if you're new to this, start with Clojure, not one
of the less-practical languages. This has made such a huge impact on the way I
think about code, write code, and design code that it's possibly the biggest
one here for me.

~~~
wing-_-nuts
Re: i3wm

I installed it a couple years ago, went whole hog, down the rabbit hole, but
realized a couple of things.

1\. I rarely ever use anything more than a simple L/R split.

2\. When I _do_ use something more complex, it's almost always in the
terminal, in which case why not use tmux?

These days I'm back to using gnome because ubuntu switched to it over unity
(which had a weird multitouch bug that drove me crazy).

What do you get out of i3 beyond a simple L/R split supported by simpler wms
and how often do you use it?

~~~
srich36
While I do use i3 for more than L/R splits with stacking etc. the largest
benefit I get from it is workspace management.

I use i3 with polybar and have dedicated workspace icons (web browser,
terminal, editor, to-do, email, music, etc) for quick navigation between
different applications. Over time I’ve built up muscle memory (i.e $Mod+3 will
bring me to my editor) that has significantly sped up my development process.
While you could use another window manager for a similar purpose, I find the
relatively minimalist approach of i3 + polybar in my case to be fast and
highly configurable.

~~~
hashhar
I can echo this! This is exactly how I feel too - the muscle memory around
workspace management and the scratch windows (floating windows that you can
toggle in/out of visibility based on a single keystroke) are the real boosters
for me rather than splits. Splits are useful but the most common use I've seen
myself do is to have a browser and a terminal / editor in splits.

~~~
Bnshsysjab
> T he scratch windows (floating windows that you can toggle in/out of
> visibility based on a single keystroke

Us the toggle an i3 concept? I’m interested in it, can you give me the
function name so I can look up doco? :)

~~~
OJFord
Not GP but I think it's `scratchpad toggle` - scratchpad is the keyword to
lookup anyway.

~~~
Bnshsysjab
Thanks, interesting concept that has some valid applications :)

------
scanr
The Jetbrains suite. Lightens the cognitive load, makes it easier to refactor
and keep code tidy. All of which allow me build better software.

For almost everything else e.g. git, learning how to use the command line
instead of a UI is the best way for me to learn how the tooling works.

~~~
cachestash
Just downloaded the GoLand 30 day trail. First impressions are I now remember
how slow and stuck in goo java based IDEs feel.

What cool stuff should I look at as I am willing to be sold on this.

~~~
apta
Jetbrains offerings are quite fast. What are you comparing them to?

~~~
infinityplus1
Probably Sublime text. It's just too fast and I can't switch to anything else.
I open heavier ones like Eclipse, VS Code etc. only when I need to refactor.

~~~
rckoepke
I notice the same thing, and I enjoy IntelliJ / Sublime / Vim. IntelliJ often
feels sluggish.

Maybe this could help: [https://blog.jetbrains.com/idea/2015/08/experimental-
zero-la...](https://blog.jetbrains.com/idea/2015/08/experimental-zero-latency-
typing-in-intellij-idea-15-eap/)

Here was a 3rd party analysis from 2015, showing a reduction in latency when
editing XML files in IntelliJ IDEA from ~70ms with large jitter to 1.7ms with
small jitter: [https://pavelfatin.com/typing-with-
pleasure/#summary](https://pavelfatin.com/typing-with-pleasure/#summary)

I wonder if it's turned on by default today, 5 years later.

Some other techniques: [https://medium.com/@sergio.igwt/boosting-performance-
of-inte...](https://medium.com/@sergio.igwt/boosting-performance-of-intellij-
idea-and-the-rest-of-jetbrains-ides-cd34952bb978)

~~~
gwittel
Seems like the IntelliJ zero latency typing is on by default since ~2017
releases.

[https://blog.jetbrains.com/idea/2016/12/intellij-
idea-2017-1...](https://blog.jetbrains.com/idea/2016/12/intellij-
idea-2017-1-eap-is-open/)

[https://blog.jetbrains.com/clion/2017/01/clion-
starts-2017-1...](https://blog.jetbrains.com/clion/2017/01/clion-
starts-2017-1-eap/#zero_latency)

------
dgb23
That would easily be using an integrated REPL.

The more integrated it is (with your IDE/editor) the better the experience and
productivity boost.

And the difference is quite large. When you are working with a language that
has first class REPL support you start to

\- 'get' why Emacs exists

\- become faster at writing code in general

\- write much more experimental and open

\- become more motivated in testing smaller assumptions and _asking questions_
about your or other peoples code

With "first class support" there are three dimensions:

(1) The REPL and the editor/IDE have to be understand each other well.

(2) The language itself has to be malleable and (de-)compose well in terms of
syntax and idioms.

(3) many things in the language are first class expressions or in other words:
there is a high degree of tangibility in the language constructs.

Most dynamic languages have workable/decent support for REPL driven
development so it is always worth testing out.

You find _excellent_ support in: Clojure (and of course other Lisps) and Julia
from my experience.

~~~
jimbokun
My main responsibility is developing and maintaining a microservice written in
Java.

However, one thing I've found invaluable over the years is developing
operational tools to support my deployed code, in a language with a built in
REPL.

At different times, I have used Clojure and Jython for this (high level way to
call my Java libraries, or to invoke APIs over the network), and most recently
Ruby (has been easy to deploy and run scripts or ad hoc commands over irb for
operational tasks, in the same environments where my service runs).

This allows me to build up code over time that I can use to

* Quickly make calls to my service to triage or debug production issues.

* Write scripts to quickly validate a new install.

* Script operational tasks at a high level that doesn't make sense to build into the service itself (can allow the service to be more stateless, for example).

* Bypass layers and make calls to the underlying database (can be more powerful than the command line tools dedicated to a specific database).

* Can be more powerful and composable than curl or Postman for making web calls.

* Have used it to analyze the state of messages in a Kafka topic (with a custom gem).

So I highly recommend building a tool set around a language with a good REPL
for anyone responsible for a service with a REST API, or any other kind of API
available over a network.

~~~
zmmmmm
Have you tried Groovy? Sounds kind of ideal if your main work is with Java. I
have a BeakerX (JupyterLab+Groovy) notebook open pretty much continuously next
to my IDE while I code so that I can validate all my assumptions as I code. A
nice workflow is that you start with a snippet of experimental code, which you
tidy up in the REPL, then it splits into the actual function and test code,
one part going to the unit test and the other to the real code.

------
antirez
Writing the overall design in plain English before writing the implementation.
Not super detailed, but the main data structures and invariants and mechanisms
that will make the implementation working. Then start the implementation
refining such document as I discover new things.

~~~
desc
This, most of all. Substitute native language if not English; the important
thing is that the project be defined and developed in both a _human_ language
and a computer language, so that mismatches can be identified and resolved.

    
    
      * Start by describing what you are trying to do.
        * Specifically.
        * Not 'build a web business to enable users to achieve their
          potential', not 'create another library for X but simpler'
          but *specifically what the software will do* and, most
          importantly, the priorities of scope increase (it'll happen
          anyway; just get the priorities and their order down in
          text ASAP).
        * Put it in a readme.txt or something.
    
      * For any given subsystem of the code (meaning: any section
        which can sort-of stand on its own) write another such file,
        in more detail.
    
      * Let these files guide your tests too.
    
      * Keep them up to date. If priorities change, *start* by
        updating the readmes. The code isn't immutable; nor is the 
        plan. But the plan comes first.
    
      * When unsure how a new subsystem or feature is going to work,
        write out your ideas and thought processes in text. Don't
        start coding at all for a day or two after you sketch out the
        basics. *Append* to this file instead of replacing large
        parts.
    

[edit] Wasn't intended to quote that part (sorry to mobile users) but I can
never remember how to get bulleted lists on this site...

~~~
sunsetMurk
Have any samples/examples you can share?

~~~
antirez
Things like that
[https://gist.github.com/antirez/ae068f95c0d084891305](https://gist.github.com/antirez/ae068f95c0d084891305).
Usually more detailed with data structures, but this one was a very conceptual
thing.

------
amirathi
Reading official documentation when working with new tools/frameworks.

Googling every hurdle as it comes & over relying on StackOverflow is neither
effective nor satisfying. Some of the projects out there have amazing
documentation (e.g. VueJS, Kafka). It's best to read the overview & skim high
level stuff to understand the core components/principles/terminologies. It
makes it so much easier & enjoyable to use those tools.

~~~
allworknoplay
Why isn't this higher?

Give everything a good read before really working. You don't need to remember
everything, but you need to know what's there so you don't wind up reinventing
wheels, endlessly googling with the wrong search terms, or doing things people
who use the tool correctly find inscrutable. It's so important.

I will note that this is much easier to do well when you're a more experienced
engineer than it is when you're just starting out, but getting used to doing
it and going back over docs when you do have more experience is the best way
to get used to it.

~~~
ribadeodev
I think the main problem with this approach is the all-or-nothing problem.
When reading official docs is not always clear when you already have
everything that you need. Reading the whole doc is usually not a possibility
considering most modern tools have easily 100+ pages that go down the rabbit
hole.

In short, good official documentation is scarce and time to read is even more
so.

------
tkainrad
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...](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.

Also, learning complex IDE features really pays off. At the very least, become
familiar with the debugger.

Finally, I spent the last months making
[https://keycombiner.com/](https://keycombiner.com/) in my spare time. It is
an app for learning keyboard shortcuts and getting faster/more accurate at
using them. It already made me more productive because I learned a lot of new
shortcuts and found some problems in my typing accuracy.

~~~
jamespullar
I would highly recommend checking out fzf for better history search. Found the
recommendation on another similar thread here and from coworkers. It's
surprisingly fast and very intuitive.

[https://github.com/junegunn/fzf](https://github.com/junegunn/fzf)

~~~
dotdi
+1 to this. I've never been a fan of how <ctrl r> works in bash, and fzf makes
it soooo much better.

------
pathartl
An actual debugger. I started as a PHP/WP dev and spent many hours running
results through echo or var_dump. IMO the debugger is the absolute first thing
you need to learn about the platform you're writing for. Without it, you're
taking shots in the dark and you truly don't know how your code is executing.

It seriously pains me to see people not using one. I have a friend who is
taking an online PHP backend class. There was one lecture on debugging, and
all it consisted of was "here's what using var_dump looks like". I showed my
friend how to actually set breakpoints in their JS code, set watches, etc and
they felt cheated by their class. They should.

~~~
maerF0x0
+1 VisualStudio w/ C#/.NET was very eye opening to the power of live debugging
code, ability to evaluate expressions and introspect vars

EDIT: I originally said VSCode, but i meant the OG Visual Studio

~~~
pathartl
I've not tried code for .NET yet. I generally like the normal-IDE-ness of
Studio

------
jtolmar
Any profiler.

As a development tool: You can default to writing the majority of your code
dumb, terse[1], and straightforward, even if you know there's a clever
algorithm you might be able to use, because that way is easier to debug.
Computers are fast and N is usually smaller than you think, and when you apply
the profiler you'll find out that that the biggest performance problem isn't
the thing you were going to optimize anyway.

As a product tool: People are more likely to buy responsive programs. The
state of modern websites is so bad that non-programmers will actually comment.
Every tester for Space Trains[2] commented on how smooth it is. That's a game,
but I've seen the same comments on productivity software I've written.

[1] As in omitting layers, not as in omitting descriptive variable names.

[2]
[https://www.youtube.com/watch?v=LRJP0tie-30](https://www.youtube.com/watch?v=LRJP0tie-30)

~~~
msohailshah
By layers, do you mean interfaces and abstract layers?

~~~
jtolmar
Yes.

Some abstractions are good, but I've seen many projects where an abstraction
layer or interface is added that does the exact same thing as the code behind
it. Or even more often, there will be one or two specific functions in the
layer that does actual work, but it would've been fine to just write a helper
function for that and not wrap everything else. It's actually pretty rare that
whatever needs to be abstracted covers an entire conceptual area to the point
where thinking of it as a "layer" makes sense.

------
the_pwner224
TabNine:
[https://www.tabnine.com/blog/deep](https://www.tabnine.com/blog/deep) (the
code are GIFs which I had to click to play)

This thing is fucking magic.

It's ML autocomplete, with help from 'traditional' autocomplete methods that
use static analysis. Instead of just completing one token at a time like
traditional completers, it can do entire sentences or multiple lines of code
in one go, and is freakishly accurate. And since it parses language it helps
you write comments, and can understand relations between code. E.g. if you are
writing 2d movement code and you do x += dx it'll automatically suggest y +=
dy for the next line based off of previous similarities; of course if you have
x += [complex math formula] it'll fix it up for y and convert cos to sin, etc.

Support for many editors, and easy to install in vim. Free for personal use.
Works for all languages, including plain English (and maybe other non-code
languages?).

~~~
gitgud
I love TabNine but had to stop using it because each instance can use 3GB of
memory... Way too much for an autocomplete extension

[https://github.com/codota/TabNine/issues/43](https://github.com/codota/TabNine/issues/43)

~~~
tinco
It's only too much if you need that memory for something else though. If it
manages to be responsive with that memory and you only have 1 ide open, I
don't think 3gb should be a problem on a modern system.

~~~
roguas
It always starts with this premise, suddenly every application no matter how
silly demands 3gb. I understand that progress often happens by putting more
attention to other aspects than economics, but again some people may value
that progress less.

------
nh2
strace.

Even after having learned many programming languages and contributed to
various projects, it was only when I started using strace that I felt like
truly, efficiently understand what any program does, and can reliably write
programs that do things fast.

I believe that "syscall oriented programming" (making your program emit
exactly and only the right syscalls) results in clean, understandable
software.

Now I use strace every day, as it is often the fastest way to figure out
problems with any tool, written in any language, open-source or proprietary.

\- Something hangs? strace shows how it's hanging.

\- Computer is slow? strace will likely show who's the culprit spamming
syscalls.

\- "Unexpected error occured"? Bypass programmers doing poor error handling,
and witness the underlying "no such file or directory" directly.

Last week I even used strace to debug why my leisure-time computer game
wouldn't load a mod, and as usual, strace did the job.

strace helps to really understand computers.

If you want to learn more about strace, check out Brendan Gregg's pages like
[http://www.brendangregg.com/blog/2014-05-11/strace-wow-
much-...](http://www.brendangregg.com/blog/2014-05-11/strace-wow-much-
syscall.html), my presentation for an intermediate-level example
([https://news.ycombinator.com/item?id=16708392](https://news.ycombinator.com/item?id=16708392))
or my project to build a programmable strace alternative
([https://github.com/nh2/hatrace](https://github.com/nh2/hatrace)).

~~~
patrec
Do not use strace. Use sysdig which is superior in just about every way.

~~~
stonogo
sysdig is useless without installing nontrivial performance-impacting
instrumentation, cannot handle non-IP networking, does not fully report all
syscalls, has a license with patent crap in it, has gated features behind a
paywall, and cannot inject syscall faults. It's not even in the same class of
tool as strace at this point.

~~~
patrec
> sysdig is useless without installing nontrivial performance-impacting
> instrumentation

Most reasonable people reading this sentence would come away with the
conclusion that strace is fast, whereas sysdig has some inherent overheads. In
reality it is strace that has performance and other problems which make it
completely unsuitable for production use (strace will slow syscall heavy code
down by a factor of over 100; sysdig won't). Sysdig, on the other than can
definitely be used in production and I always found the performance overhead
minor. Can you point to something showing otherwise? BTW, newer versions of
sysdig do not require a kernel module, thanks to eBPF (but I have not used
this).

> , cannot handle non-IP networking,

What is an example of a networking related query you can do with strace but
not with sysdig?

> does not fully report all syscalls

Can you expand? Are you referring to the fact that sysdig will drop traces if
the userland client cannot keep up (which is a feature and not a bug, and
something that all production grade tracing tools do)?

> , has a license with patent crap in it,

As far as I'm aware sysdig's core is Apache licensed and the user scripts are
MIT and GPL licensed. Apache has a patent grant, which seems better than not
having one. What is your specific beef?

> has gated features behind a paywall,

What features that strace offers are behind a paywall in sysdig? What's wrong
with a company that provides a tool that massively advanced the (linux, pre-
eBPF) state of the art as open source for free to all also provide some paid
offerings on top?

> and cannot inject syscall faults.

This is indeed a useful recent-ish feature I did not know about so thank you!
But there are other ways to do it, and something that's orthogonal to the core
tracing functionality.

> It's not even in the same class of tool as strace at this point.

Indeed -- the only reason to use strace at this point is because you already
know it and it is likely available. This may change if strace switches away
from ptrace, but for now it is a joke. If you want something that just does
strace, but much better (minimal overhead, powerful and intuitive query
language with CLI autocompletion) use sysdig. If you want to use the most
general and powerful tool that can tell you lots of other stuff besides
syscall usage (but has a much worse UX) look at eBPF and perf. If you want to
be a serious performance engineer or similar you will have to learn it, but I
suspect for most people sysdig has the best ROI. Perf and dtrace are both
(far) more versatile but, IMO, (far) less pleasant to use.

------
hinkley
If you consider processes as tools, there's one that I suggest to junior
programmers bucking for responsibility/promotions.

Twenty minute cleanup. Nobody is really going to notice if you spent 5 hours
or 5:20 on a task. As you're closing up and getting ready to push your
changes, look if there's anything you can do to make it look or work nicer.

Eventually you start incorporating some of the lessons learned doing this into
your implementations.

~~~
ayberk
+1 to this. I've developed the habit of reviewing my PRs before publishing
them. When you assume the role of a reviewer, you end up catching a lot of
little (and sometimes big!) stuff, reducing the total turnaround time.

~~~
tudorpavel
+1 to self code reviews, I almost always find stuff I've missed or could have
done better.

~~~
kyleashipley
I often comment on my own PRs to explain alternatives or tradeoffs I
considered. These aren't necessarily worth capturing in permanent
documentation or TODOs, but can share knowledge or build confidence that I've
considered various angles that might come up in a review.

I'll also call out places where I'm not happy with the implementation, looking
for feedback, etc.

------
edw
For many of the tools that have improved my productivity, it was not the tool
that was the breakthrough but the _realization_ of the tool’s value. For
example, version control has existed since the beginning of time practically,
and I begrudgingly used RCS, SCCS, VSS, and probably other version control
systems for ten or fifteen years until I had that Eureka! moment (coinciding
with Git’s release, roughly) that inspired me to actually _embrace_ version
control tools. A similar experience happened with automated testing: I’d
gotten the testing-is-good bondage and discipline spiel many times, but it
wasn’t until I started writing extensive units tests for language parsers that
I realized how wonderfully empowering they can be.

That said, along with Git, I’d list Gdb (or LLdb or any real debugger), Emacs
keyboard macros, Python’s venv facilities, and Django’s database migrations
among the tools that changed my life.

Somewhat consistent with the it’s-not-the-thing-but-the-realization-of-the-
thing’s-value theme above, I’d say reading the Practice of Programming back in
‘99 took my programming productivity to a new level, because it made me
realize that one of the central tasks of an abstraction builder is creating a
language that allows you to express thoughts in terms of that abstraction.
Once you’ve done that, you “just” need to implement the language and all of
the problems expressible in it become easy, even trivial.

------
robbyt
Using multiple programming languages.

Using Golang has helped me create better data structures, and using C helped
me understand linking, using python helped me understand closures, and using
Ruby helped me understand that I hate programming.

~~~
metapsj
can you elaborate on ruby? i'm curious to understand your experience with it
and what brought you to the conclusion that you "hate programming".

~~~
freehunter
I'm not the original person so I have no idea what their experience is, but I
feel pretty much the same. Every time I work in a language other than Ruby, it
feels like _programming_. When I work in Ruby the language feels almost
effortless. I wish I could do everything in Ruby and it frustrates me when
there is something I can't make work in Ruby. Especially Rails, everything
that works works so smoothly. When it doesn't work I get very frustrated and
switch to another language only to find out its _even harder_ in another
language.

I don't like programming. I like it when the computer does what I tell it to
do. I find that drastically easier to accomplish in Ruby (especially Rails).

~~~
cosmojg
What are your thoughts on Crystal?

See: [https://crystal-lang.org/](https://crystal-lang.org/)

~~~
karmakaze
Would you like to pay now (compile time) or later (runtime)?

We have ways of dealing with scaling of runtime in production (develop
infrastructure environment).

There's no way I know to speed up the edit/compile/run loop during
development.

------
louib
The vi mode for Bash. Blew my mind when I discovered it and it probably saved
me hundreds of hours already. I used to have multiple copies of this
cheatsheet [0] at my desk for every new developer I would see editing a
terminal command with the left and right arrows.

[0] [https://catonmat.net/ftp/bash-vi-editing-mode-cheat-
sheet.pd...](https://catonmat.net/ftp/bash-vi-editing-mode-cheat-sheet.pdf)

~~~
jmchuster
I dunno, I don't think it really gets you more than just adding some basic
mappings

    
    
        # mappings for Ctrl-left-arrow and Ctrl-right-arrow for word moving
        "\e[1;5C": forward-word
        "\e[1;5D": backward-word
        "\e[5C": forward-word
        "\e[5D": backward-word
        "\e\e[C": forward-word
        "\e\e[D": backward-word
    
        ## arrow up
        "\e[A":history-search-backward
        ## arrow down
        "\e[B":history-search-forward

------
fouric
magit ([https://magit.vc/](https://magit.vc/)) - a git interface for Emacs.
Hyper-interactive and ergonomic, feels like vim for git. Highly pleasurable to
use and makes you significantly more efficient.

SLIME ([https://common-lisp.net/project/slime/](https://common-
lisp.net/project/slime/)) - a Common Lisp development environment, also for
Emacs. Comes with a REPL, interactive debugger (way better than gcc), the
normal IDE-like experience you know and love, and this fantastic tool called
the Inspector that is basically an interactive, modal editor for your program
data. The Inspector is one of the most novel and useful tools that a
development environment can have... and I've never seen another IDE that has
anything resembling it. SLIME gives you a highly interactive and fluid
development experience that I've never seen anything else come close to.

Spacemacs ([https://www.spacemacs.org/](https://www.spacemacs.org/)) - a
starter kit for Emacs that gives you a _sane_ out-of-the-box configuration and
an optional pre-configured Evil (vim keybinding emulation) setup. Much more
flexible and powerful than Vim (elisp, while a bad general-purpose language,
runs circles around vimscript) and much better ergonomics than vanilla Emacs
(Emacs' mode-less interface is just straight-up worse for your hands than
Vim's modal interface).

------
UYChuH
If your after specific tools in a workflow...

\- the :normal command in Vim and Evil. \- learning to use tags to navigate
code.

But more generally learning how to take something seemingly complex like Linux
or Git and then delve in and read the code and understand how it _actually_
works. Learning to read good technical books and manuals and understand how
something was designed and how it was designed to be used.

Colleagues think I work magic; in reality I'm just as thick as they are, I
just RTFM.

~~~
unemphysbro
hahaha...that's my 'secret'

recently I've been paralyzed by the amount of development in ML/DL/RL. Often I
have to step back and remind myself to focus on the fundamentals.

------
piinbinary
I'm going to re-interpret the question more broadly than just "tools" (unless
you consider a technique to be a kind of tool):

* Taking good notes

* Writing good plans, good documentation

* Sharing updates and coordinating with the right people at the right time

* Understanding an unfamiliar codebase

* Test frameworks

* Different design techniques (pure functions, dataflow programming, etc)

* The terminal and related features (like emacs bindings, or middle-click to paste last selection)

* Firefox/Chrome devtools

* Emacs keyboard macros

~~~
bob1029
I can no longer count on my fingers how many massive coding efforts from our
backlog evaporated into nothing because we sat around and thoroughly talked
through the actual business cases.

------
typenil
Most of my productivity gains these days has come from aligning myself and my
workstation.

\- i3wm ([https://i3wm.org/](https://i3wm.org/)) - particularly getting
comfortable editing the .i3/config. It's the most significant productivity
change I've had since switching to Linux from Windows.

To get into it, I highly recommend this 3-part video series from Code Cast:
[https://youtu.be/j1I63wGcvU4](https://youtu.be/j1I63wGcvU4)

\- yadm ([https://yadm.io/](https://yadm.io/)) - a dotfile manager. It's
essentially a git wrapper, but it's allowed me tons of freedom tweaking my
setup without worrying about persisting it.

It supports encryption and switching file versions based on which system
you're on.

~~~
mxschumacher
fast switching between workspaces + efficient use of screen real estate +
great hotkeys make i3 truly great, I have used it for many years and don't
want to miss its minimalism

------
l0b0
_IntelliJ IDEA_ has taken refactoring from being a chore to being trivial,
consequently making me much more likely to clean up ugly code when I encounter
it.

 _Black,_ the Python code formatter, means I don't have to spend a single
brain cycle on styling the code.

 _mypy_ (with a strict configuration) has forced me to think about types,
making for code which is much easier to follow and integrate with. No more `if
isinstance(list, param)` or similar faff.

 _Bash,_ even with all its footguns, is a great lowest common denominator for
getting a vast array of stuff done.

~~~
civilian
Do you have an example of the configuration you use with mypy? (If you could
post it in a gist I should would appreciate it! I've done a couple mypy
tutorials but I haven't pulled the trigger on adding it to my projects.)

~~~
l0b0
[https://gist.github.com/l0b0/b655d155c5cfc509c339cd0b1cd494c...](https://gist.github.com/l0b0/b655d155c5cfc509c339cd0b1cd494cf)

Beware that if you're not yet using mypy I would not recommend starting with
this - it's a lot of work to get to the stage where this succeeds. I'd
recommend starting with no configuration at all and adding one setting at a
time so you give yourself time to learn what they all do and how they help.

------
jordanpg
Jetbrains IDEs have been mentioned already, but I'll add a specific feature of
Jetbrains IDEs, the Productivity Guide[0].

This contains a list of keyboard shortcuts and tracks your usage or non-usage
of them, identifying various ways you can speed up your workflow in the IDE
using keyboard shortcuts instead of the mouse.

Building on this, the Key Promoter[1] plugin will notify you when you could
have used a shortcut instead of the mouse.

Reclaim seconds of your life wasted moving the mouse around.

[0] [https://www.jetbrains.com/help/idea/productivity-
guide.html](https://www.jetbrains.com/help/idea/productivity-guide.html)

[1] [https://plugins.jetbrains.com/plugin/9792-key-
promoter-x](https://plugins.jetbrains.com/plugin/9792-key-promoter-x)

~~~
severine
Interesting...

Does something like this exist for Excel? Asking for a friend (seriously).

------
thewebcount
The static analyzer. There are so many subtle things that aren't caught by the
compiler and don't cause any problems in your testing but will definitely come
up once 10M users are running your app. The static analyzer can catch some of
them before you even run! It's great.

The various sanitizers - Address Sanitizer, Thread Sanitizer, Undefined
Behavior Sanitizer. These all also find things before you ship. They require
(re)building and running but it's worth it.

Beyond that, any sort of instrumentation that can show you in real time
information about your running application. You can see memory growing, even
if it's not leaking. You can see performance tanking and know the exact
function that's causing it before you quit.

Beyond that, for me using a framework that was well written made understanding
architecture much easier. I had used MFC and CodeWarrior PowerPlant for a few
years. They got the job done and were easy enough to use, but I didn't really
learn anything from them. But when I moved to using Cocoa, it was so elegant
and the separation of concerns was so good that it clicked and really taught
me a lot about better architecture.

------
fosspowered
PlantUML[1]: Drawing any diagram helps me to have something concrete as it
makes me think of the various components, connections and the invariants. It
also gives a bigger picture.

It is also very easy to learn and can be embedded anywhere rendered by Plant
UML server or the rendering can be handled by your internal plant UML service.

[1] - [https://plantuml.com/](https://plantuml.com/)

~~~
Jtsummers
There are several VS Code plugins for PlantUML and Graphviz that allow for
live rendering. That has proved very useful for communicating ideas without
needing a drag-and-drop interface, and the result is a file that I can drop
into a git repository.

~~~
kyawzazaw
There is a JetBrains extension too!

------
randylahey
Choice of editor is subject to taste, but I find VI/Vim keybindings and modal
editing an absolute must-have for productivity.

~~~
entropicmind
I agree. When first learning Vim the learning curve is very steep for what
feels like basically advanced cursor moving but with more experience it
becomes a very powerful text editor. Last week another I had a 10,000 line
file that was the output of a bash command with two columns and each column
was in quotes. I needed to remove the first column and the quotes around the
second column. There are many ways to do it but all I had to do was open up
vim and type `qaA<backspace><esc>T"d0jq` and `10000@a` and cleaned it right
up.

~~~
smitty1e
As an opinion, [https://vimvalley.com/](https://vimvalley.com/) was well worth
the investment.

I use [https://www.spacemacs.org/](https://www.spacemacs.org/), but modal
editing is a win.

------
daenz
\- rr, the time-travelling debugger[0]

\- intellij, or any good ide. seriously, we underappreciate everything these
tools do and can do for us.

[https://en.wikipedia.org/wiki/Rr_(debugging)](https://en.wikipedia.org/wiki/Rr_\(debugging\))

------
zoomablemind
Better at coding and better Programmer not always converge.

To become a better programmer, I find _testing_ is a big booster. Not only it
helps demonstrate compliance to specs, it also adds more confidence that
you're in control of the code. It let's you experiment and change approaches.

Also I find a good help from _IDE_, even a simple as Geany [1], that lets me
jump between the functions and also hint at the args. It saves time, and,
again, adds confidence when exploring/extending new code.

And finally, the most imporant booster - _learning my limits_.That is when
it's time to ask for help and not feel too defensive about peer review. This
goes hand in hand with knowing what a good team is. Not just wishing for it.

------
1e-9
My biggest improvement came from eliminating a tool. It was when I stopped
using debuggers (except maybe once a year) and invested more time in creating
efficient runtime error checks and internal self-tests. Debuggers make me
lazy. I find I can solve the vast majority of my bugs more quickly with a
little thought rather than running to a breakpoint and examining things.

Most useful tools:

\- tmux

\- vim

\- catch
([https://github.com/catchorg/Catch2](https://github.com/catchorg/Catch2))

------
tchaffee
Lately, using Jupyter notebooks. It's a paradigm change, and pretty close to
what I would imagine Donald Knuth had in mind with literate programming. Just
for example, being able to see the shape of variables and having that output
stay there between coding sessions is a huge time saver. Add being able to
plot data and using other visual tools right inside your code and well, I
could go on and on. Just try it. It's like a REPL but with memory.

~~~
shostack
How do you integrate it into your workflow? Is your program scattered across
blocks in a notebook or is it easy to pull everything together once it works
the way you want?

Also, thoughts on jupyter vs co ok colaboratory?

~~~
tchaffee
Late response, but in case you are still looking I don't think I have enough
experience just yet to talk about my workflow. For the moment, I'm mostly fine
with just running my entire notebook. And yes, my program is "scattered"
across cells in a notebook. And that's useful. The blocks are the small units
I would want to debug, or to document with markdown above the block.

However, you might look to Jeremy Howard of fastai [1] fame for some
direction. He apparently built the entire fastai library using notebooks and
nbdev [2] which allows you to "add #export flags to the cells that define the
functions you want to include in your python modules."

I have tried out nbdev in my free time, and it's pretty cool.

[1] [https://www.fast.ai/](https://www.fast.ai/) [2]
[https://github.com/fastai/nbdev](https://github.com/fastai/nbdev)

------
keithnz
Resharper (and now all the various Jetbrains tools) - from the early days,
this tool allowed you to aggressively and automatically refactor code. Before
that, in the C# world ( and many other languages ), there was very little in
the way of automatic refactoring tools. Not to mention it's automatic
suggestions on code transformations or more efficient use of the language are
super useful.

Vim Bindings - While I often don't use Vim, I use Vim binding in most any
environment I use. I don't know if it really made me a better programmer, but
it improves the experience of programming.

Unit Testing tools - making code testable makes code modular.

Visual Studios Debugger, fantastic debugging tool from years and years ago.
While I don't use it as much anymore, it's been a useful tool in understanding
code.

Google Search, transformed the way to get information, coding information was
hard to come by a few decades ago, now it is prolific.

------
desc
I prefer to internalise useful ways of thinking rather than leaning too much
on tools, on the grounds that the latter are easy-come-easy-go while the
former can last a lifetime.

Learn to explain what you're building, why, and more-or-less how it works in a
context appropriate to the listener.

(Related: write things down. Again and again, differently, until you
understand them.)

Problems and their solutions usually have similar structures.

Any fix right now might save a lot of money. The right fix next week could
save years. Often both are appropriate, but the latter is nearly always most
valuable.

The world does not change nearly as fast as your competitors want everyone to
believe it does, but people's beliefs can.

A tool which warns you of possible mistakes before consequences occur is
always more valuable than a tool which tries to guess what you meant and does
that instead.

------
agentultra
If you think of languages like tools I find Haskell particularly productive.
The type checker gives me a whole program view of every branch and I can
interactively query my program thanks to strong inference and good tooling.

Mastering a good emacs setup has boosted my productivity with git and having
OS-agnostic tooling for linting, debugging, shell, document publishing, email,
etc.

------
dcchambers
\- git. Not just commit/push/pull on a single branch - but getting really good
at using git is a game-changer.

\- vim. I started off in linux sysadmin land before pivoting into more regular
software engineering work, so I was very good as basic vi(m) stuff because
it's ubiquitous in linux/unix servers. However I've learned its just as
valuable as a full-blown IDE/dev environment if you're willing to invest in
learning and configuring it. I think newer editors like Atom/VSCode/IntelliJ
are still very valuable and great tools, but Vim really is incredible.

\- An understanding of unix history. Maybe it's just the type of work I do,
but knowing why things are the way they are is incredidbly valuable.

~~~
rovr138
Regarding understanding unix history.

I actually think that knowing the history of whatever you're working with, is
good and really valuable.

If you don't know the history, you don't know how things came to be and why
things are the way they are. This applies to language, code, product,
organization, tools, etc.

You can treat things like a blackbox and use them. They'll work for a while
but every time you see something that doesn't work, you'll spend time and more
time trying to figure things out. Do/Learn things once.

Ask questions. Sit with people that know. Ask smart questions -
[http://catb.org/~esr/faqs/smart-
questions.html](http://catb.org/~esr/faqs/smart-questions.html)

I've been using git for years. But I decided to really dig into it to find out
how things work. These are good links and there are actually many more good
ones about git internals out there.

\- [https://git-scm.com/book/en/v2](https://git-scm.com/book/en/v2) \-
[https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protoco...](https://git-
scm.com/book/en/v2/Git-on-the-Server-The-Protocols) \- [https://git-
scm.com/book/en/v2/Git-Internals-Plumbing-and-Po...](https://git-
scm.com/book/en/v2/Git-Internals-Plumbing-and-Porcelain)

------
zeroxfe
\- Version control

\- Unit testing

\- Leak detectors (for languages like C/C++)

\- Race detectors

\- Auto-formatting (eslint, gofmt)

\- A solid editor (prev: vim, now: vscode)

\- One-step deployment scripts/automation (even for small projects)

I have not found a lot of value in debuggers, outside of after-the-fact
debugging (e.g., core files.) I much prefer printf-style debugging.

~~~
nickysielicki
> I have not found a lot of value in debuggers, outside of after-the-fact
> debugging (e.g., core files.) I much prefer printf-style debugging.

Have you heard of/tried rr? I think you might find that it fits your thought
process better than traditional debuggers.

[https://rr-project.org/](https://rr-project.org/)

~~~
zeroxfe
Never heard of it, but I'll take a look. Thanks for the pointer. :-)

------
ninjakeyboard
Learning functional programming will make you a better developer in all
languages IMO. This is the single biggest vector for understanding how to
write maintainable code.

Similarly learning design patterns will probably make you a worse programmer
but learning the heuristics behind them (eg composition over inheritance) will
make you a better programmer.

Learning DDD will make you a better programmer by understanding how to use
bounded contexts to manage complexity as software grows.

------
furstenheim
\- tests in watch mode. Either with --watch if I'm doing js with mocha or
inotify if I'm doing another language. Tests or compile should execute on
save, which in turn I configure in autosave.

\- making sure that I can execute everything from the console. It makes
tickets reproducible, for my future me and my coworkers.

\- go. Error handling in go has very bad press, mainly because it's boring and
repetitive. But one builds the habit of handling all cases.

~~~
Jtsummers
`fswatch` is a cross-platform way of monitoring file system changes, versus
`inotify`. I use it for testing in the same manner as you describe, very
helpful to have one tmux pane with code and another constantly showing the
results of test execution.

------
catears
I'll add two really simple, but also very effective tools. Search: in the form
of things like "the silver searcher"
([https://github.com/ggreer/the_silver_searcher](https://github.com/ggreer/the_silver_searcher))
or "fd" ([https://github.com/sharkdp/fd](https://github.com/sharkdp/fd)). And,
Replace: with tools like sed
([https://www.gnu.org/software/sed/](https://www.gnu.org/software/sed/)).

These are really simple tools but they are also very powerful. I have
surprisingly often needed to change from version X.Y.Z to version A.B.C in
some set of files (be it package.json or requirements.txt or *.csproj) and
tools like these make it happen in an instant.

Most recently they have helped me with some spaghetti code where the software
is used in several places and I need to ensure exactly which places use the
KerfuffleManager. Can I trust my IDE to find all places where it is used?
Maybe, but with proper search tools it stops being a trust thing.

~~~
lucianbr
In the same vein as silver searcher, I'd mention ripgrep:
[https://github.com/BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)

------
Agentlien
Vim. I felt like I was slowly going crazy due to the friction between my
thoughts and the commands needed to navigate through the code. I was just
looking for a tool to solve that and happened upon an article about Vim. A
teacher had tried to show me Vim in high school, but I slowly backed away from
his crazed stare. But now, I came to it of my own volition. It's great. It
feels like the one tool which allows me to freely express what I want without
getting in the way. Add to this a suite of simple yet powerful tools, such as
recursive macros, which mean I can usually automate tedious and repetitive
tasks.

------
zenlot
Emacs. Specifically Doom Emacs.

[https://github.com/hlissner/doom-emacs](https://github.com/hlissner/doom-
emacs)

~~~
kleiba
Emacs. Specifically vanilla GNU Emacs.

[https://www.gnu.org/software/emacs/](https://www.gnu.org/software/emacs/)

------
sam_lowry_
Shell, awk, sed and textutils. They teach that programming is everywhere.

I have trouble understanding professional challenges of people that never had
a chance to learn those. Like accountants struggling to merge tables or
proposal writers painfully tuning document layouts.

~~~
elt0r0
Any recommendations for resources on learning more about these commands?

~~~
ravoori
Shell - for bash, I'd recommend the Bash Guide from Greg's Wiki
([https://mywiki.wooledge.org/BashGuide](https://mywiki.wooledge.org/BashGuide))
For awk 1\. Chapters 1 and 2 from the Awk Programming
Language([https://ia802309.us.archive.org/25/items/pdfy-
MgN0H1joIoDVoI...](https://ia802309.us.archive.org/25/items/pdfy-
MgN0H1joIoDVoIC7/The_AWK_Programming_Language.pdf)) 2\. Awk one-liners
([https://www.pement.org/awk/awk1line.txt](https://www.pement.org/awk/awk1line.txt))
3\. Explanations for one-liners ([https://catonmat.net/awk-one-liners-
explained-part-one](https://catonmat.net/awk-one-liners-explained-part-one))

------
nurettin
I install the largest whiteboard I can find. My current office has one that is
over 2 meters across. Having a huge space to discuss architecture is valuable.

~~~
afarrell
I second this. Also, whiteboard notecards and neodynium magnets.

------
p4l4g4
\- Solid editor: I've used a few editors and IDEs in the past. I think a
learning to use a programmable editor is a better investment than learning to
work with an IDE. IDEs are generally single purpose: working very good for a
limited selection of languages, platforms, etc. Having a good editor at your
disposal allows you to manipulate any text oriented (and sometimes binary)
format. When your editor is programmable and has an active community, you can
probably find a plugin to solve your problem more effectively or write
something yourself, with your editor! With all your customizations in code,
you can manage your editor in the same way as you manage your products: source
control! This gives you the possibility to improve your daily working
environment reliably and iteratively. IMO, Vim and Emacs are both very good
options. Both were created decades ago and still have very active communities.
Personally prefer Emacs and use vim on occasion for remote work.

\- Learn basic vim and emacs keybinds: most interactive shells use readline
(or similar) library. These shells often have emacs keybindings by default.
Vim is often the alternative option. This was an eye opener while learning
emacs: suddenly I started to understand how to efficiently navigate any shell,
even remote systems, without configuration!

\- Tcl: Easy to learn, hard to master and powerful! Syntax and semantics can
be explained in 12 bullet points[1]. Bundled with the native tk library, its
my goto language for quick-n-dirty GUI tools and prototypes. The "every thing
is a string" principle makes it extremely flexible. Apart from quick-n-dirty,
it's also used for stable tools such as expects, gitk and environment modules.
Even sqlite and redis started as tcl scripts!

\- POSIX shell scripting and core utils: write once run anywhere.

[1]
[https://tcl.tk/man/tcl/TclCmd/Tcl.htm](https://tcl.tk/man/tcl/TclCmd/Tcl.htm)

~~~
bitwize
Tcl/Tk is still the fastest way to get from zero to functional GUI that I've
ever seen. I wish I could say there was something of similar ease in Lisp, but
alas there isn't -- not in the current ecosystem of Unix workalikes running on
generic CISC/RISC hardware. Maybe the Lisp Machines had something.

~~~
dragonwriter
> Tcl/Tk is still the fastest way to get from zero to functional GUI that I've
> ever seen.

PySimpleGUI seems pretty great for that.

~~~
blacksqr
PySimpleGUI wraps tkinter and thus ultimately Tcl/Tk.

------
rb808
leetcode.

I hate I have to do these stupid exercises to be able to get a job, but I have
learned some useful skills by looking at how I write code and comparing to
faster solutions. It has changed how I write normal code, and helps me write
automatically without thinking too much.

------
spaetzleesser
For me it’s profilers. A lot of people keep optimizing their code without
actually having hard data. Being good with a profiler has often allowed me to
go in and get significant improvements quickly because I could attack the code
section that really took a long time vs the code sections where _think_ the
time is going.

Also having detailed logging with time stamps helps a lot in identifying where
the code spends most of its time.

~~~
coob
Regular scheduled 1:1 meetings with those I work closely with. Does wonders
for teamwork / relationship building.

------
MrQuincle
That's easy, every time I did something new I learned a lot.

First time

\+ Linux.

\+ Shell scripting.

\+ Grep, regex

\+ Embedded development, configuring ADC hardware, e.g.

\+ FPGA, designing FSMs, adders, etc.

\+ Reverse engineering anything. Use a logic analyser. I just learned the
details on HDMI a week ago, for example.

\+ Vim, and sticking to it in the beginning. :-)

\+ Basic sysop stuff, ssh, rsync, dig, etc.

\+ Cuda.

\+ Tensorflow.

\+ Javascript. Definitely if you come from a C angle. Playing with modern
frameworks doesn't hurt!

Of course those are not just tools, but they all help understanding what's the
best tool for the job. :-)

------
AdrianB1
\- Git - quite self-explanatory

\- Visual Studio Code - I like more than the paid version (that I have a
subscription for)

\- SQL Server Management Studio execution plan modes - it is a gem that few
people know about and even fewer can utilize it effectively to make 10 second
queries run in 30 milliseconds.

\- Composer (PHP) as my first encounter with package management, years ago.

\- Notepad++ - the only mini-tool available in production

\- Virtual machines and snapshots. Never fear again about ruining the work
environment and helping a lot with having separate dev/stage/prod environments
without breaking the bank. Also a way to split and separate my environments,
the laptop is for emails, VM's for everything else.

PS. I am not a programmer, I am officially a manager and mostly an architect,
but I write code to keep current

~~~
dunefox
There is a paid version of VS Code?

~~~
Chickenosaurus
Maybe the person meant to say Visual Studio Code is preferable to Visual
Studio.

~~~
wenc
I feel that Visual Studio Code (a free programmer's text editor) suffers from
its poor branding -- it's too easily confused with Visual Studio (a paid IDE),
so folks dismiss it out of hand because of the perception that it's not free
or is only for MS languages like C# (neither is true). Microsoft should have
called it something else.

As a Vim user of 2 decades, I have to confess something: VS Code is a far
better programmer's editor than Vim. It's pretty responsive, has seamless (and
better) integration with language servers [1] than Vim, has better
autocomplete than Vim (due to said language server) and the Vim keybindings
are not terrible.

For the first time, refactoring (renaming variables) is easy because the
editor now understands the language-specific structure of the code as opposed
to the code being treated as a long string. It's possible to attach a language
server to Vim but it's fiddly and doesn't work that well.

[1] [https://langserver.org/](https://langserver.org/)

~~~
ComputerGuru
I have no problems using LSPs for C/C++ (via clangs), rust (rust-analyzer),
Python (pyls), JS/TypeScript, CSS, bash, and more in Vim (Well, NeoVim) with
the autozimu language client.

~~~
wenc
The experience is a bit different in VS Code.

To me, in Vim it feels a little bit like one is calling an external program
(which one is), and the monospaced text-only UI constrains what can be shown.

In VS Code, the experience is more integrated (because the GUI isn't
constrained to a text interface), things update live, so you can preview the
changes before applying.

I've tried both, both work but I find myself preferring the VS Code
experience.

------
kortex
Immutable infrastructure / functional programming / crash-only code. In
conjunction with lots of docker, ansible, studying FP, and trying to adopt
these principles in all my main languages (python, go, c, c++, bash)

Those 3 ideas all kind of mushed together radically changed my overall
approach to development. What do they all have in common? Avoiding complex
state.

State is hard to reason about. Each piece of state that can interact
introduces combinatorially-growing complexity.

Crash-only code may seem like the odd one out but think about it: if your
program dying at literally any point has the potential for data corruption,
you probably have some sort of issue with state management.

I guess you could call it anarchy coding, because it tries to completely
eliminate state ;)

------
wruza
\- vim, grep, regex, cli (i.e. fundamental text tools, no “ide” plugins)

\- no “intellisense“, only word completion

\- write down my operative “what do I do now” stack on paper (helps to not
lose yourself in a forest of thoughts and fixes)

The second one I found very effective, because instead of guessing what
function or method does or how many of them are there, you go to man/html docs
and read on what it really is, how it works, and what its error modes are.
This way I learn much more about APIs that I use, read rationales, caveats and
more.

Also, intellisense when done wrong (and it often is) gets in your way and
creates non-deterministic time-dependent _modes_ for your input, even worse
than vim-anxious people usually criticize it for.

------
easterncalculus
I do think that your keyboard can help not only mitigate health risks
associated with typing all day, but can make the actual act of writing code go
from annoying to enjoyable. What works for you is a subjective question (I
don't think that mechanical keyboards are the best for everyone, if I'm
hoenst), but a good keyboard can really go a long way.

~~~
AllanLRH
Guess an ergonomic keyboard could help prevent some injuries.

------
bttrfl
Pico. Without it, I'd still be searching how to quit vim :)

But jokes aside, all kinds of real-time log aggregators make big difference
for me. Once upon a time, I had acquired first huge customer and had to set up
analytics service as a single-tenant deployment. I acquired better servers
than usual, installed the service and started processing the traffic only to
find out that we can handle only 1/50 of the contracted traffic. For the next
48h or so I pushed hundreds of changes to production and watched realtime
charts in Splunk going from 1/50, 2/50 to 50/50\. I saved the contract and
saved the company and went to bed.

------
simonw
Continuous Integration tools.

I started with Jenkins and hated it, because it really encouraged
configuration through an awful web interface. CI configs should live in
version control!

(I know you can do that with Jenkins these days but I still haven't figured
out how myself).

Then I got going with Travis CI and loved it - then Circle CI, then GitLab CI
and today I'm mostly using GitHub Actions.

Every single personal project I build uses CI now. My tests, packaging and
deploys are all automated from day one. It's an enormous productivity boost
and lets me manage way more projects without worrying that I'll forget how to
test them / package them / deploy them.

------
wozer
Property-based testing.

I believe it can be a real game changer. It can enable a normal programmer to
create the same quality as an excellent programmer.

An introduction: [https://fsharpforfunandprofit.com/posts/property-based-
testi...](https://fsharpforfunandprofit.com/posts/property-based-testing/)

------
jb3689
\- Erlang/Elixir: taught me functional programming, pattern matching,
recursion, supervision, how to achieve fault tolerance

\- Docker: taught me about server management and immutable infrastructure;
paved the way for a lot of concepts (containers are surprisingly foreign for a
lot of people)

Other than that: learning about different databases in general and learning
how they solved the problems they had and why they solved them that way; the
same problems come up over and over and it's important to be able to recognize
good ideas from bad ones as well as when to recognize solved problems from
novel ones

------
jschulenklopper
Touch typing - learning it during this WFH phase, as much more communication
is done typing.

------
benjohnson
Putting this in my hosts file helped me maintain my focus.

127.0.0.1 news.ycombinator.com

127.0.0.1 reddit.com

127.0.0.1 facebook.com

~~~
sneeuwpopsneeuw
Yhea this is nice but this simply does not work on all websites. The edge
between working and browsing the web can be very thin on some websites. For
Facebook it is easy just block it completely but reddit and youtube are
difficult so what I do is that I use a plugin called stayfocused it allows you
to set a amount of time (for me 30 min) that you are allowed per day to be on
the websites you listed. On my second browser I place no restrictions like
that but use ublock origin to block everyting untill it is broken. So for
example i remove the recommendations from youtube and it's search bar. On
reddit I remove the list view so only a single post shows correctly. For me
this works way better because the rules are fair and that makes sure you do
not just remove the entries from your host file for example just a few days
after you entered them.

~~~
esperent
Why is reddit hard to block? I put that in my hosts from time to time and it
works fine.

The real problem is how incredibly hard it is to set edit the hosts file on
mobile. At least without using a VPN app or something.

~~~
sneeuwpopsneeuw
When you are programming in some lesser known graphics frameworks like libgdx
or when you are using OpenGl then the special Reddit subpages are more active
than stackoverflow. For example I implemented a framebuffer in OpenGL wrong a
few weeks ago but the output then is just a black screen. Some redditor
mentioned that specific thing in a comment on /r/OpenGL

------
princevegeta89
Can't imagine writing code without Jetbrains IDEs. VSCode is great for
lightweight editing. On the other hand, I have other tools like CopyEmPaste:
[https://apps.apple.com/us/app/copyem-paste-clipboard-
mgr/id8...](https://apps.apple.com/us/app/copyem-paste-clipboard-
mgr/id876540291?mt=12) This is a great clipboard manager and helps a lot with
Copy-Pasting.

------
dugword
Perl. CLI one-liners or small one-off scripts.

You can do so much automation and data munging so quickly with it that it
really makes you feel like you have superpowers.

~~~
oblib
Yeah, I still use perl for most all the server side stuff I have to do.

------
rco8786
Read the docs!! Even the bad ones are better than none.

I can't count the amount of times I've been working with a more junior
engineer and I'm just rattling off answers to their questions..then at the end
I realize that I have 5-6+ tabs worth of documentation open that I've simply
been referencing throughout our conversation but they think I'm some walking
encyclopedia of knowledge.

------
revskill
To me, it's functional programming in general and Haskell specifically.
Thinking in function actually helps me become a better programmer !

------
heinrichhartman
Lots of great tips/tools here. Let me add this to the list:

Dash [https://kapeli.com/dash](https://kapeli.com/dash)

Makes browsing documentation really fast and convenient. Have that bound to F1
in my emacs to lookup the current word at point. So you instantly zap to man
pages, lua reference manual, python docs, perl docs, ... you name it. Highly
recommended.

------
bitwize
1) Emacs. Still the king of text editors, with even the latest challengers
(e.g., Visual Studio Code) proving unworthy. Nothing beats an editor you
modify for the task at hand live as you edit.

2) Scheme. It started with writing plugins for GIMP in its embedded Scheme in
the 90s, then I moved on to Guile -- but Scheme not only made programming fun,
it put solving a greater class of problems within my reach, especially when I
had to solve them quickly. When I need to explore an algorithm or rough out a
prototype for how a system might work, I reach for Scheme -- and even when I'm
not working in Scheme or another Lisp, I bring its lessons with me.

3) Darcs. This was my first DVCS, before git, and it enabled me to more easily
use version control on my own independent projects and prepared me for a git
workflow.

4) Linux, and open source in general -- for providing me with a free OS, free
tools, and lots of code to examine for ideas and inspiration. Back when I was
faffing about with Windows programming as a teenager, this was a real game
changer.

------
allworknoplay
Going to the source!

Using a framework or library? You'll get so much better so much faster if you
look at what the authors have done.

It's often (I find) easier than looking at random open source projects since
you're working closely with the tool anyway. It will help you debug or prevent
weird things, teach you techniques you didn't know, and give you a sense for
what to strive for.

------
kirstenbirgit
Using an actual, proper IDE instead of text editors with plugins that have so-
so language support.

Learning how to operate a computer efficiently. Use keyboard shortcuts. Set up
scripts for commonly used tasks. Configure our environment and operating
system so it's less annoying.

Being efficient at using a computer also makes you annoyed at poor UIs, and as
a result, better at building great apps.

The ability to write things down, and finding joy in writing documentation.
I'm continously surprised at how many people will have a 3 hour meeting and
just not write anything down, or never make any comments or READMEs in their
projects.

Understanding to use the right tool for the job. You don't need to use the
latest and greatest container orchestration, library, or whatever.

Not caring about non-business effecting minutiae, like spending time doing
code-style nitpicks in pull request comments (when automated tools can do the
job), has made me more efficient and less tolerating of the tendency
programmers have to focus on non-important things.

------
stared
ESLint (and other linters, preferably used with the strictest rules) - while
at the very beginning it was annoying, it helped me write much cleaner code.

Longer version here: [https://p.migdal.pl/2020/03/02/types-tests-
typescript.html](https://p.migdal.pl/2020/03/02/types-tests-typescript.html)

~~~
franciscop
Prettier, it helps me having clean code without worrying about writing clean
code :)

It does take a bit to get used to it though, but then it's a lifechanger.

------
Curzel
Maybe the opposite of many other comments but... macOS. Limited choices and
customisations, but less is better. Not having to worry about "stuff" is
something that goes easily undervalued.

~~~
brightball
That’s exactly why I’m using Ubuntu instead a more customized linux distro
atm. I will say that after 2 years and a couple of updates, the idea of a
rolling release version is sounding better.

------
Pabblo001
It can sound stupid but I’m newbie so for me: * Firebase - moving my ideas
from local host to online and be able to present this / get feedback. That
was/is motivating me to solve more complex problems.

* JS challenges website like coderbyte edabit

* honorable to mention- Hardcore Functional Programming in JavaScript, v2 from front end masters

------
soumyadeb
I started my career programming in Vim on VT100 terminals
([https://en.wikipedia.org/wiki/VT100](https://en.wikipedia.org/wiki/VT100)) -
yes, I am old.

There was no IDE, auto-complete, visual debugger etc. You really had to think
before you typed any code. Even fixing compilation error was a pain - you had
to note down the line number and the error, go back and open vim, fix the
error, exit vim, re-compile and rinse and repeat. Taught me the paradigm of
thinking hard about the problem before starting to code and I think that has
helped a lot.

This was still better than the punch-card days I have heard but I personally
never had the experience.

------
graton
Not strictly a better programmer but a more efficient one.

\- FZF (Fuzzy Finder) really speeds thing up in bash when searching your
history.

\- Vim (as others have mentioned). With the plugin vim-fugitive (a git related
vim plugin). I love Gblame in vim-fugitive, as being able to look at the
history of lines of code and stepping back in time can at times be very
useful.

\- Creating various aliases. For example in git I have little aliases which
just make me faster. "st" = "status", "rbi" = "rebase --interactive", "ci' =
"commit", etc...

\- Using The Silver Searcher (ag) or Ripgrep (rg) instead of grep. Much faster
than using grep.

\- Using 'fd' instead of find. Like above it is a lot faster.

~~~
mxschumacher
I've installed rg and aliased it to to grep, so the muscle memory stays the
same but underneath the tool is changed.

Also works for

ls -> exa

cat -> bat

~~~
ComputerGuru
exa completely breaks ls arguments/switches and as such is a hard pass for me.

~~~
mxschumacher
I have since switched to lsd:
[https://github.com/Peltoche/lsd](https://github.com/Peltoche/lsd)

------
flohofwoe
Using a step debugger and stepping through all the code I just wrote, or using
it to explore code other people wrote.

Surprisingly this seems to be a very uncommon use for a debugger, some
programmers are mislead by the name and only use it for actual debugging ;)

------
xs83
\- Debugger - doesn't matter which one - just stop using echo / print for
complex debugging.

\- Good IDE - I prefer Jetbrains products, once you learn all the shortcuts
for the various functions it just makes things much faster than constantly
switching between windows.

\- Sublime text - Not as an IDE but columnar editing and fast construction /
munging of data files is crucial for efficiency

\- Linux / Bash / Shell - learn the tools - sure you can write a script to do
most things but learning how to pipe some commands together to get some
certain output is universally useful. Learn the basic VIM key bindings, you
should be able to comfortably copy,paste,save,select etc

------
jamespetercook
Typescript - defining interfaces before doing any work is like visual
planning. Adding it to old projects highlights a lot of unknown issues.

VSCode - right click a keyword > go to definition made me more comfortable
navigating code written by other people.

------
gregwchase
Docker. Being able to develop/ deploy code across a team and business is
invaluable.

~~~
cowmix
100%.. for all the crap Docker gets these days, it has been a great tool for
my software dev processes.

~~~
takeda
I don't know how the infrastructure was before docker was introduced, but for
me it made things more miserable. Build times are longer, if you work on OS X
it eats up battery and causes it to heat up (because on OS X it runs inside of
VM). Makes things so much harder each time you make change you have to rebuild
it to run it, unless you do some tricks that aren't always possible in all
languages. You can do development inside of a docker, but that also has its
own issues, primarily you can't use your fancy IDE.

------
itqwertz
MacBook Pro.

After years of dealing with a Windows workstation, I went into credit card
debt to purchase a quality laptop computer for my development needs.

I have had the same one for 6 years and found little reason to buy a new MBP.

~~~
foepys
Lenovo ThinkPads are similar in build quality and processing power while being
significantly cheaper and they have a usable keyboard. Same for Dell XPS, I
believe, but my company is using ThinkPads.

Windows is usable even for node and git development nowadays.

~~~
Jefro118
Can I ask if you've tried using one with Linux (Ubuntu or Mint)? I'm thinking
of getting a ThinkPad next but I would prefer to use Linux over Windows and
I'm wondering how well it runs Linux.

~~~
ufo
Thinkpads are very popular among the Linux crowd.

The only thing that doesn't work in mine is the fingerprint reader.

~~~
bibelo
Yes same here. It works 1 time out of 10. Really annoying

------
idoby
Learning how to use the compiler and type system (if your language has them)
to get as close as possible to "if it compiles, it works", is invaluable.

Novice programmers just want the code not to error out, and compile, they just
want the compiler errors to go away, while more experienced programmers learn
to use the errors as a todo list of sorts, at first, then as a guide for
refactorings and fixing bugs.

Learn to harness the compiler and type system to help you, and your coding
will improve 10x in both velocity and quality.

------
sandermvanvliet
NCrunch: [https://www.ncrunch.net](https://www.ncrunch.net)

It has helped me so much in applying TDD rigorously in every app that I write
by giving me very quick feedback on code I write.

The simple fact you can refactor something and within seconds know if
everything still works is a massive time saver and that allows me to write
better tests. It also makes flaky, slow and coupled tests visible as you get
used to the speed of test execution that the “bad” ones jump out at you.

Well worth the license

------
brightball
Foreman

[https://github.com/ddollar/foreman](https://github.com/ddollar/foreman)

When I learned Ruby a while back. I know it doesn’t sound like much, but it
was the first tool I’d used in development that showed me _how_ I develop is
critically important.

It’s just a simple tool to start and stop several tools in the background,
streaming the logs to all of them in one place. At the time, I’d never seen
anything like that and felt like I’d been doing it wrong for years.

------
morty_s
\- vim

\- grep (now using ripgrep)

\- code navigation

\- rust

\- functional programming (scheme, Erlang, Haskell, Elixir, etc; structure and
interpretation of computer programs).

------
sushshshsh
Understanding that this whole industry is a giant house of cards, bs stacked
on top of bs. Don't take anything personally, memorize the language needed to
succeed

------
chad_strategic
Years ago I switched from Mac OS/Apple when I became a developer/data
scientist to linux based system. (ubuntu)

I understand there are similarities between MAC OS and Linux... etc. Being on
the same OS as most of the web servers saved me time in learning the basics of
linux, bash, etc.

Also at the time I couldn't afford to keep buying new software license.

The only enterprise software I use is Navicat for user frienldly interface
into databases.

~~~
kedean
In a similar vein, I am a primarily a mac user today after growing up on
windows and linux (personally and for developments that run on linux as the
end-system). I am quite confident that already having an intimate familiarity
with Unix is what really unlocks MacOS as a powerful developer environment. I
find myself much more appreciate of the positive differences that it provides
over Linux and BSD, and much more understanding of deficits and things it
won't let me do than I think I would be without that familiarity.

------
kadams54
I wrote a blog post about this:

[http://blog.testdouble.com/posts/2020-04-07-favorite-
things/](http://blog.testdouble.com/posts/2020-04-07-favorite-things/)

Outside of that, I'd say linters and code formatters have a huge impact on my
productivity and code quality. ShellCheck in particular has taught me oodles
about shell scripting.

------
jedberg
> What have you added to your workflow that's made you much more productive?

A second monitor and tiling window manager (or in my case Magnet, which adds
simple tiles to MacOs).

When I added a second monitor to my setup my productivity exploded. It's just
really nice to have one window full screen in my IDE and the other window with
reference material, a shell, scrolling logs, etc.

Never having to switch away from the code is huge.

------
cosmotic
Jetbrains tools help point out better ways to do the same task and learn about
new language features by identifying slow or compatible code then instantly
refactoring to the better or newer version for you. It makes learning new
language features easy because it gives you examples in context with code
you're familiar with. (among many other ways the jetbrains tools are great)

------
mikekchar
TODO lists for which I use org mode, but you could use practically anything. I
like a text editor for this rather than an app, per se, just because it keeps
me in the flow. All you need is a place to jot down what you are planning to
do next and to be able to arrange the order.

Usually I'll start with pretty high level ideas. If I have a story I'm working
on, I'll put the description of the story in my TODO list. Then I'll think for
about 5 minutes about what general things need to get done. I'll order these
by some priority (doesn't really matter usually, to be honest). Then I'll
start working on the first one.

Normally I need to poke into the code to really see what I have to do. I'll
often add a sub-task to my first one that says, "Figure out what to do" or
something like that. Then I'll do some exploratory coding for a few minutes.
As I discover what needs to get done, I write it down in my TODO.

It's hard at first to stop yourself from just writing code, but pulling
yourself back for the 20 seconds or so it takes to write down what you are
just about to do can be surprisingly valuable. Don't censor yourself either.
It's fine to guess what you need to do and then delete stuff that you realise
is unnecessary later. As you are coding, any time you think, "Oh, I'm going to
need X", add it to the TODO (again, difficult to train yourself to do it
consistently!)

Once you get good at this, in my experience you will be quite interruptible.
Any time I get distracted, or unfocussed or lack motivation, I just look at
the top think on the TODO and say, "I'm just going to do that top thing". It
always pulls me in.

I don't always code like this, but every time I do I'm dramatically more
productive. I _should_ always code like this, but... sometimes you want a
relaxed day ;-)

------
lioeters
That's a good question, I'm curious what comes to mind, tools that have helped
me as a programmer..

\- Git CLI as well as GUI - The latter for me is as essential as knowing
(enough of) the commands and options

\- grep and find

\- TypeScript

\- VS Code - Language server integration like type checking as I edit, and go
to definition; syntax highlight with personal color scheme - I feel so cozy
writing code, the colors enhance understanding, and the aesthetics of it
definitely shapes the result to be small and beautiful; remote edit over SSH;
keyboard shortcut to apply prettier formatting

\- Linux real and virtual machines as "commodity" computing resource,
available on (or from) anywhere

\- GitHub - It could have been anything else, but having a social platform
with an ocean of open-source code to study, discuss, contribute.

\- Keeping notes in Markdown, as a kind of personal knowledge database

\- Curated collection of libraries for common needs, written from scratch,
forked, or as dependencies

------
teknopaul
Sonar: code formatting nagware for Java. I spent a few months being very
strict with code style and it has made me permanently a more productive
programmer. I used to look at my code and wonder how to improve it, now I know
what to do until I'm happy with it. I've learnt to apply this to other
languages. Sonar showed me how to make code consistent, that is easier to
read, write, grep and work with.

An unexpected result of being anal about whitespace for a few months was
productivity with large code bases.

I no longer have Sonar itself in my workflow. But I defo feel that tool made
me a better programmer.

This is not really a recomendation for Sonar but a recomendation to go find a
relevant code style tool and work with it until it you are no longer learning
code formatting and you are learning code clarity.

------
voldybot
[https://fishshell.com/](https://fishshell.com/)

------
waiseristy
* Zsh + Grep + Awk + Vim : Essentially 90% of my daily driving around my PC at work.

* ZimWiki : Have a notebook VCS'd in my home directory sync'd across my PC's. Amazingly easy way to take notes and keep track of work.

* Jetbrains CLion, Pycharm, IntelliJ : The best cross platform IDE. Bar none

------
brailsafe
JetBrains products help me understand a new codebase more efficiently, and
basic use of ls and tail on unix based machines help me parse log files
faster. SelfControl on mac helps me block distracting websites and Klokki
helps me track my time. Bear is a great note taking app that I've mostly
switched to from Evernote. I like GitHub's new Android app.

In terms of actually being a better programmer, I believe anything that helps
you collect or parse information about your running code and debug it will
improve your life. Sometimes that's print statements, sometimes that's a
remote debugging session.

My most regularly used commands are probably `ls -lt | head -20` and `tail -f'
or `tail -1000 | grep`, so maybe learning a bit about pipes too.

------
vmchale
I quite like nm + ripgrep. There is a lot I don't understand about the C/Unix
world (in fairness it's not all in textbooks) but this was the first step to
understanding the "unix command line is my IDE" mindset which I found so odd.

Also fd-find, just plain useful.

------
simonw
Interactive interpreters and notebook interfaces.

ipython for Python, then later Jupyter notebooks.

Firebug for JavaScript, which then got built into every browser as the dev
toolbar.

These days [https://observablehq.com/](https://observablehq.com/) for
JavaScript too.

------
kushalpandya
StackOverflow (and Stack Exchange network in general).

------
majormajor
\- visual debuggers

\- automated tools for simple refactorings (renaming and the like)

(you can read both of the above as "JetBrains" ;)

\- source control

\- REPLs

\- personal logs / "lab notes" \- keeping a record of how I did stuff for the
next time I need to do something similar. "source control for non-code" kinda

------
manicdee
For me, not having Visual Studio, Jetbrains, etc has made life easier overall.
I have to design code with low intellectual overhead, since I no longer have
fancy tools detangling spaghetti for me.

So I use BBEdit and Oh My ZSH for just about everything.

For git interaction I love Fork.

------
huhtenberg
assert() that is not compiled away in release builds. A miracle discipline
drug that makes people think through what they are trying to code.

------
easymovet
QBasic, everything since then has been incremental.

------
zjy
The _ag_ the silver searcher

As programer, finding/looking up the code takes your primary time. so after I
got into _ag_ , it changes my behavior of checking the code. from somewhat
_lookup_ to _searching_.

------
gwbas1c
Google + examples

I remember learning to program C in the 1990s as a teenager, and often taking
a long time just to learn how to do something very simple. This was mostly
because the compiler-provided documentation was sparse, and the books that I
had only had a single point of view.

Now, I can Google "[language] [task] example" and read through 2-4 examples of
how to do something. Then I can go back and look at the docs and they make
significantly more sense. Often what would take 4-6 hours, or longer, to
figure out from just the official language / API documentation can be figured
out in 20-40 minutes.

------
mellosouls
A couple of tools so far not mentioned, that have been hugely beneficial to
me:

1\. Copernic Desktop Search _pre version 3_. The version I use is over ten
years old and still looks and works better than any other desktop search
product I've ever used. Instant results when searching your file and network
system, presented in a format appropriate view. Please note that the version
is important here, it went from being a stunning piece of freeware to a worthy
corporate product years ago.

2\. Trello. Every non-trivial task I undertake is managed through here, it's
so simple and flexible.

~~~
PTOB
Took me awhile, but (here it is) [[https://copernic-desktop-
search.software.informer.com/downlo...](https://copernic-desktop-
search.software.informer.com/download/)].

~~~
mellosouls
I assume they are the same ones as available through the website?

[https://www.copernic.com/en/products/desktop-
search/previous...](https://www.copernic.com/en/products/desktop-
search/previousversions/)

Unfortunately, from version 3 the free version was severely restricted and I
assume it has been chipped away at ever since.

eg. [https://pinkeyegraphics.co.uk/copernic-desktop-
search-3-a-na...](https://pinkeyegraphics.co.uk/copernic-desktop-
search-3-a-nasty-downgr/)

I'm still on 2.x, it's brilliant though.

There are still legit copies floating about somewhere I'm assuming; it was a
free product, it's just no longer available from them.

------
shawnsbrain66
I'm a Windows programmer, but I use: UltraEdit - to say it's a text editor is
to say a Ferrari is a car. Powerbasic - a lot of people don't know PB and
Python came out the same year. Fast, powerful, full access to windows API,
pointers, classes, tiny EXE's, can use any standard DLL, and can make DLL's.
JellyFish - a PowerBasic IDE that is, in my opinion, better than the PB native
IDE Paint Shop Pro - a far cheaper and easier alternative to PhotoShop with
all the stuff I need

These are the 3 tools I use the most to make my living.

------
city41
Here is a similar conversation from about a month ago:
[https://news.ycombinator.com/item?id=23118940](https://news.ycombinator.com/item?id=23118940)

------
oblib
Since you mention "more productive" I'll focus on that first.

Reading the docs and example code for opensource libraries and tools I use
when I get stuck, as opposed to trying to figure out how to use them myself.
And using google to search for answers to question and heading to
Stackoverflow if it's been answered there and reviewing all the answers
offered.

It's a habit now, but it took me awhile to break my previous habit of thinking
I could figure stuff out without help and I'm much more productive as a
result.

As far as tools go, BBEdit is the one I use most.

------
schwartzworld
if you're writing JS and don't have Prettier installed, you're missing out. It
integrates seemlessly into IDEs and editors, so you can just write code
without worrying about formatting.

------
pirsquare
Solarized Color Scheme - You spent more time looking at your code than you see
your spouse. A good color scheme reduces fatigue especially when you are
working through your code for long periods.

~~~
ragnese
What color scheme helps with looking at my spouse? Ba dum tss!

------
cstuder
Keeping a developer journal, digitally, so it can easily be searched.

(I'm using a simple extension called `vscode-journal` in my text editor, it
writes daily markdown files stored on my Dropbox.)

~~~
thewebcount
+1! I do this as well, in particular a debugging journal. It allows me to find
solutions to problems I've hit before. It's very handy to have a recipe for a
fix without having to rediscover it again.

------
lstamour
Not every job needs this, but when your company has a lot of code, it helps as
a newcomer to spend time writing documentation. Those who “level up” in this
skill can write documentation _everyone_ understands, not just other
programmers. For instance RML instead of UML: [https://seilevel.com/business-
analyst-resources/rml-book/](https://seilevel.com/business-analyst-
resources/rml-book/) Now, if you have BA resources on your team, or
designers/UX folks, then use them. There are teams where other people do the
business-understandable diagrams and you’re doing technical ones. But... if
your team is smaller, or the code is already written, then it’s just as
helpful for you, as the developer, to also be the one communicating how things
work to the business and stakeholders. It will help everyone use the same
terminology—simplify decision-making—and since you made the documentation
while looking at the code or existing APIs, you can assure folks it is
relatively complete and accurate.
[https://www.youtube.com/playlist?list=PL2miG2CzrxakbZswQH-O4...](https://www.youtube.com/playlist?list=PL2miG2CzrxakbZswQH-O43G5VnJ0_CB8C&feature=share)
has some videos on business-friendly documentation and SeiLevel folks also
contributed to two Microsoft Press books on software requirements and visual
models.

I’ve found that mapping out the business domain, or explaining complexity, is
at least half my job sometimes. Advocating for SRE best practices seems to be
the other half. ;-)

For very large systems, DSMs are interesting.
[https://mitpress.mit.edu/books/design-structure-matrix-
metho...](https://mitpress.mit.edu/books/design-structure-matrix-methods-and-
applications) But generally extremely technical and useful only to those
creating the DSM.

Oh— also ASTs. Kind of a form of code documentation, but knowing how to use
AST Explorer to read and modify a call graph or source code is incredibly
liberating. It’s great to suggest we can make breaking changes and fix them in
client code using an AST transformation, etc.

Finally, “A Philosophy of Software Design” was a nice quick read that I still
get value from, but it doesn’t address how tests and ASTs could help; it
covers the evergreen basics though.

------
bobbydreamer
In mainframe ISPF, F1 is usually help and F2 split screen. I have changed that
like with F1 when I keep my cursor over a dataset it going into that dataset
in view mode and with F2 I have made to swap list it shows all ispf screens I
have open.

Swapbar at the bottom of the screen and in SDSF always have SET DISPLAY ON.

Other than that, its hardware lapton keyboard type. I am faster when pgup /
pgdn and home/end are separte keys rather than combination of fn and other
keys.

------
romes
Flycut. It's a clipboard manager. I hit cmd+shift+v and I can scroll through
my previous clipboard states. It's an amazing upgrade from a one-state-only-
clipboard life.

"Flycut is a clean and simple clipboard manager for developers. It based on an
open source app called Jumpcut. Flycut is also open source too:
[http://github.com/TermiT/flycut"](http://github.com/TermiT/flycut")

~~~
hota_mazi
If you're using Windows 10, you already have this: press Windows-v.

The clipboard can also be shared across your Windows devices.

------
vmception
git blame inside of the IDE.

line numbers, jumping to lines. shockingly this isn't default in IDE and I
frequently still have to learn how to enable it.

autocomplete and quick way to get a list of available methods for an object,
based on the actual library or things the object inherits. Javascript IDEs
seem to just show a random list of frequently available functions, instead of
the actual ones indexed - likely because they are all the same type.

------
austincheney
JSLint hands down. There is a lot of sloppiness in JavaScript and that tool’s
motto is: _JSLint will hurt your feelings._

The idea was a heavily opinionated code validation tool striving to make code
subjectively cleaner and clearer for strangers to read. Many people stopped
using it because they claimed it was too opinionated, even though every other
super popular/trendy JavaScript tool claims to be just as opinionated.

------
kashfi
If you're a Java developer and learning pointers I recommend using the Java
Visualizer.

[https://cscircles.cemc.uwaterloo.ca/java_visualize/](https://cscircles.cemc.uwaterloo.ca/java_visualize/)

Copy and paste the class you're working on. Include a main() to act as a test
driver and then let the Java Visualizer step through your code showing you
exactly what is going on.

------
royalghost
Sublime has definitely increased my productivity and if I have to select one
command, it would be the ability to select and update all instances of the
word - [https://stackoverflow.com/questions/12162047/how-to-
select-a...](https://stackoverflow.com/questions/12162047/how-to-select-all-
instances-of-selected-region-in-sublime-text)

------
rubyron
The Pomodoro technique has helped my productivity more than anything. So much
so that I built Timmy ([https://timmytimer.com](https://timmytimer.com) ) and
added social features for some added motivation (all timers are public - think
of it like "Twitter for productivity"). Free and no login required if you want
to try.

------
axegon_
The single biggest contributor: vim. Not relying on fancy IDE's with smart
autocomplete and all that. You end up learning the internals of a
language/library without relying on the IDE to do it for you. It became my
weapon of choice around 2009-2010 and now I can't remember the last time I had
a syntax error. Browser for documentation and vim is literally all I need.

~~~
godelski
Just for reference, vim does have built in completion. <C-p> and <C-n> in
insert mode will complete a word. Also in insert mode <C-x><C-{n,p,l,f}> are
contextual completions (see :h ins-completion for full list, I suggest not
using the dictionary because it takes awhile). I have found that contextual
completion has changed how I program in vim and it seems to be one of the
lesser known features. It is way more powerful if you're using
buffers/panes/tabs, which all three have greatly improved my programming as
well (in different ways).

------
ydnaclementine
I've had a few people newer people reach out on how to level up recently, I
recommended:

\- vim, but more of the hotkeys than vim itself for me (ex: idea vim).
Productivity gains + always have a usable text editor in any env (ssh, local,
etc)

\- clean code book, to help know what good code looks like, and gives
structure to shoot for, and gain opinion on why one way looks better than
others, or not

------
hprotagonist
intellisense and friends.

As a junior developer, method documentation and autocomplete on demand are
crutches i leaned on VERY heavily with great success.

------
justsomeuser
\- Google

\- Pen and Paper for scribbling thoughts

\- Bicycle in green areas

\- Javascript - closures, async/await, JSON

\- SQL - Designing a normalised schema before coding clarifies relations

\- Docker - just because it forces you to think about the dependencies of your
code explicitly

\- Evernote - improves my thinking and cements learning

\- JetBrains IDE - I pay a small amount to not have to deal with a mishmash of
plugins competing with each other when moving between languages.

------
closeparen
Do everything in your power to find out what's actually happening with a bug;
don't just guess.

\- SQL

\- Your metrics system's query language

\- jq

\- sort / uniq

\- grep

\- awk

\- pyplot

\- mapbox (if you have geospatial data)

\- your environment's canonical profiler, and how to connect it _in situ_

\- how to poke the relevant APIs with your bare hands (curl, grpcurl, etc)

\- how to MITM and inspect the communications between your components
(wireshark, charles, certificate trust stores, feature flags to disable
pinning, etc)

------
erichurkman
Your preferred language's debugger. It really does show in coding interviews
who has control over their environment and can debug rapidly. It doesn't
matter if it's rudimentary pdb (basic python debugger) or LLdb, understanding
how to structure code such that it's easily testable -and- debuggable is a
hallmark of a senior developer.

------
openfuture
Experimenting.

Tools that make it easier to do experiments are good, I tend to think too much
and read too much but the only way to get better at programming is to put your
ideas to the test and implement them (starting with simplified versions, i.e.
experiments).

Modelling is something I want to get into, alloy and tla+ look like great ways
to sketch out higher level ideas.

------
edpichler
When I finished my post-graduation in "Software Engineering". I feel so
productive. I can release anything with very high quality if I have the
necessary resources, and rework is a thing from the past. I can control the
chaos, release often and confidently still having really good nights of sleep.

------
zitterbewegung
In no specific order or magnitude.

1\. After or during a tutorial to make a silly easy project to perform
synthesis after I learn how to do something. Or using a tutorial and then
basing my idea off of that.

2\. Understanding when and how to do incremental changes.

3\. Understanding the reason of source control and learning a git, subversion
and CVS.

4\. Learning Python.

6\. Learning lisp

7\. Emacs and org-mode

------
PostPlummer
Pen & paper.

It helps me getting away from the drive to 'just give it a shot' and forces me
to work so much more structured.

I still love to doodle with a pen and different color markers and it allows me
to have it permanently in view on my desk with the option to add boxes and
arrows as required.

------
Frank93
I'd like to suggest CodeFights, it is great platform for software engineers to
practice for cosing interview in then in turn get the desired tech jobs. And
one more tool for developers is ProofHub. It is the one place for all your
projects, teams and communications.

------
tonyedgecombe
ReSharper, I probably wouldn't have got around to understanding LINQ without
its regular prompts.

------
gofreddygo
Focusing on my habits and practices over tools and technology has driven more
productivity and sanity in my career.

Early on, finding new tools, languages, libraries and frameworks was
exhilarating and something their knowledge was I cared deeply about and worked
towards. And soon, I cared more about the tools and the language than the
problem itself. Caring about the medium caused more pain and wasted time than
joy and productivity when any one of them broke, when they didn't do what I
wanted them to do, when I found a new tool that was older and more mature than
the one I used, when someone disagreed for no good reason, when someone used a
worse tool than ones I knew. I have wasted hours toying around with shiny new
things only to realize later what a waste it all was. They all promised, never
delivered.

The point where things got better was when I started keeping simple logs.

At work, it was mostly putting into words the problem I was facing, why it was
interesting, how have others solved or avoided this, what possible solutions I
could find, ideal and realistic solutions, pros and cons of each, whom should
I convince for this, who can help, why would they agree or oppose. As things
progressed, I kept adding updates and how things actually turned out. In
personal life, its been about people and projects. People I've met, people who
have helped me, people whom I'm indebted to, people whom I hold dear and those
that I keep away from, memories and arguments, what I'm grateful for and what
I want to change.

They are interesting to read after the fact. I've learned more from this
practice than any person, blog or book. I've been more productive when I see a
pattern emerge and going back to how I handled things before. Highly recommend
it. Moreover, It helped me find good and bad habits, how I respond to what
happens around me, what gets me worried and upset, what makes me happier, more
productive. The 'right thing to do' is obvious looking back now but never make
sense looking forward. What seemed like promising projects did not turn out
so, People who seemed like friends, weren't.

So what tool did I use for this? Email. I kept drafts, one for each idea,
problem, story, lesson learned etc across the different email accounts I had.
When they were good enough, I'd sent them over to a separate email account to
keep it all in one place. Ironically, I started keeping logs after getting
frustrated with a good way to keep my notes.

Sun Tzu would say "Make the enemy fear not the weapon, but the hand that
wields it."

------
ineedasername
regular expressions. Both in programs, and in text editors that support regex,
where I eliminate the need to write some small utility program by using regex
instead. Combine with sed & awk and it's an incredibly powerful combination.

------
vitorbaptistaa
If you can call them a tool, tests would be close to the top of my list. One
of the most important metrics for productivity is how quickly you can get
feedback if something you did worked. A fast test suite is great for that.

------
soulnothing
* Arch Linux / Manjaro. AUR is a great resource for the latest packages

* i3 / sway. I've built a number of custom patches on top of it.

* Windows Aero Snap - a close second

* MacOs - Yabai + skhd a very distant third. Mac doesn't just play as well with tiling.

* LibVirt / Virt Manager / CockPit / VFIO. I have a number of VMs emulating mac, windows, and linux. My workstation is all three in one. I also have a local kube cluster spun up via the libvirt api.

* JetBrains - Tool Suite They're tooling is phenomenal

* vim / nvim - My secondary editor for quick changes.

* Visual Studio Code - Primarily for remote sharing work spaces.

* Git - I keep almost everything in a git store of some sort.

* zsh and oh my zsh, great plugins.

* Kitty - terminal with the kittens plugins is great

* Direnv + EnvFile, dynamic loading of container env vars on entering a directory

* GitLab - Despite it's warts the best dev ops cloud agnostic platform I've used.

* Kotlin - I'm able to do pretty much everything in this. From vim over ssh or jetbrains. I use it for infrastructure, k8, mobile, web, and back end.

* Gradle - I curse at it a lot, but less than other build systems. I have templates that allow me to quick start any of the above templates.

* Remote Desktop - I keep a cheap dedicated server I RDP for heavy work loads while away from my workstation

* Reg Ex Pal - to validate reg ex

* Functional Programming

* Markdown / Restructured text - Great way to write docs and draft architectural plans

* MermaidJS, Lucid Chart - Easily embedded in markdown to provide graphs of architectural patterns.

* OpenAPI/AsyncAPI/GraphQL - Schema driven design let's me write the schema first, then generate type safe routes for the server, and clients for the consumers (web/mobile)

* Avro, Protobuf, Json Schema - For defining messages going across the wire.

* Containers - I started with solaris zones and it has been vital to my workflow.

* Docker Compose - This is the lowest barrier to providing a container stack for local dev. Next would be KIND.

* Docsify, Sphinx / etc. Easy way to add architectural docs next to the api docs as part of git pages.

That being said, I generally am unable to use a majority of these in my day
job. So I'm operating much slower than I'm capable of.

------
bconnorwhite
Extra RAM for your brain - whiteboard film surface on your desk + 4 monitors.

~~~
jaredtn
Interesting. How does that work when you want to rest your forearms while
typing?

~~~
PTOB
Plot twist, user has no arms.

------
kartayyar
Bazel. I really like the workflow of how it only selectively runs unit tests.

------
eitland
\- a good IDE (contains debugging, code look up, code completion, automation
of boring parts like selective recompile, refactoring, linting etc etc)

\- version control (unlike you, mostly the basic parts, the safety net)

\- testing libraries

------
Ayesh
\- git: specially branching, rebase, and GitHub PR etiquette.

\- regex: the deeper topics such as backtracking, look behinds, etc help too.

\- How DNS works: how they work, TTLs, etc.

\- How TLS works: performance and security tweaking.

\- SQL: modern SQL can do quite a lot!

------
throwawaygo
Read code. Every code. All the codes. You are striving to learn strategies for
organizing abstraction. Tools are great but your thinking will move faster
with a larger vocabulary for organization.

------
theCodeStig
\- Lambda Calculus, and Functional programming principles.

\- Thinking in terms of types and structure, rather than linear procedures.

\- Category theory.

\- Vim as a language for editing text.

\- Emacs (my own config w/ Evil).

\- Nix.

\- A documentation specific browser, such as Dash.

\- The latest grep flavour - ripgrep.

------
smitty1e
Pytest => [https://docs.pytest.org/](https://docs.pytest.org/)

Making the smallest, most granular problems out of the bigger ones is the key
to vict'ry.

------
haidrali
Rubocop made me a better programmer in terms of writing clean, readable, and
consistent code.

Also at the organization level no it keeps codebase consistent no matter how
many programmers work on the same codebase.

------
anarchyrucks
GDB.

------
synthc
Magit, before I used Magit using git was a chore, now it is a pleasure.

------
vesinisa
jq - I deal a lot with JSON in my work (who doesn't these days?). jq is a nice
tool for transforming and extracting specific data from JSON. Like awk, it's a
Turing-complete DSL.

------
snypox
Investing time customizing VS Code. Today, I end to end manage my project from
VSC: create new branch, code, publish branch, open PR. I have shortcuts for
certain git commands too.

------
diegoperini
FinderPath[0]. It taught me what macOS looks like in its fs.

[0] [https://bahoom.com/finderpath/](https://bahoom.com/finderpath/)

------
nickysielicki
* `perf top`

* `scan-build`

* [https://github.com/pwndbg/pwndbg](https://github.com/pwndbg/pwndbg), a very comprehensive gdb extension/config.

------
rozgo
Apple II, TRS-80. Quake engine. Haskell, F#, Rust. Type theory, domain and
test driven design. Philosophy, economy. Linux. Physics engines, PyTorch,
GStreamer. Twitter.

------
darkport
Docker. Which hasn’t really helped me get _better_ at writing code. But my God
it’s helped my productivity and I’m finishing more and more side projects
because of it.

------
shruubi
The big thing for me was discovering JetBrains products and how much care and
thought is taken in building a product that provides the right tools when you
need it.

------
xzlzx
Incorporating a clipboard manager into my workflow was a game changer for me.
It's basically a cache for my mind. I couldn't imagine life without it now.

~~~
xcubic
Which one do you recommend?

------
arc_of_descent
While programming in Elixir, iex. I spend most of my time in the REPL, testing
my functions, learning new features, and of course the recompile command!

------
erikerikson
[https://en.m.wikipedia.org/wiki/AspectJ](https://en.m.wikipedia.org/wiki/AspectJ)

------
mmargerum
Watching Rich Hickey videos.

Cider REPL

Literate programming in Org mode

Keeping outlines of notes in org mode for everything. Being able to execute
the code in those notes is pretty friggin amazing.

~~~
xcubic
Could you give your top 5 Rich Hickey videos for begginers?

------
thellimist
Being able to read code from similar projects in Github.

It allows you to do better design, learn how to write readable code, and allow
you to move faster.

------
code-faster
my json toolkit has been a huge boon for me, it complements jq very well:
[https://github.com/tyleradams/json-
toolkit](https://github.com/tyleradams/json-toolkit)

There's tools for converting between json and other data formats like xml as
well as misc tools like json-diff which diffs json files and formats the
output as json.

------
Shicholas
New Relic, APM is important, and grokking this or a similar tool (Datadog,
AppDynamics, Solarwinds) can only make you much more productive.

------
efferifick
* fuzzers

[https://blog.regehr.org/archives/1687](https://blog.regehr.org/archives/1687)

------
jimmaswell
IDE features may be my biggest productivity boost.

------
toastal
Learning how to use type holes has really helped a lot in recent years.
Learning how to grok documentation and source code as well.

------
pinopinopino
\- xmonad

No distractions and I can program my window manager to organize my windows.

\- git

I was once fan of mercurial, but I like git better now. Everytime I find new
interesting ways to use it. Also outside it's traditional uses.

\- (n)vim

I use other editors, but I turn them into vim. It is easy to use and makes
typing in your solution of your problem in the language of choice less boring.
(The coding part)

\- awk

God, I love awk. It is like the swiss army knife of unix. You can do
everything with it.

\- latex

If I want to order my mind by writing a bit or making a nice design, create
some documentation. Latex is your friend.

\- dot

If I want to sketch something, dot will help. Dot also helps with other stuff,
dependencies between things. It is easy to write out a dot file.

\- profilers

Any fucking profiler will make your a better programmer. It will test your
assumptions about the underlying model.

\- debuggers

You can't do things without them ^_^

\- static type systems

Learn to think in types is a big win and not a weakness. You can encode
properties in type systems.

\- mathematics

Learn it, use it. It will give you new ways to think. E.g. algebra is about
composability. So first thing I do is when I have a problem is write out the
data types and think out its algebra. And it keeps your mind active, just
churn through some mathematical topic once in a while. I loved type theory.
Lambda calculus, abstract algebra, linear algebra and am know learning point
set topology.

\- esoteric languages

They are fun and force you to rethink what computation is. Design a couple
yourself. I can compute in any language with weird constraints. I just need to
build a machine in it.

\- keep playing around

Not everything you do needs to be a project, just make something useless. E.g.
I like jotting down shit in netlogo, which is utterly useless, but fun to
watch.

\- zsh

Where am I without you? ZSH can interface with everything. I write small tools
from finding ec2 instances in the cloud by tag to presenting searchable menus
binded by keys with a little help of small programs.

\- the core utils

Learn them by heart, you will never have to click ever.

\- Learning new programming paradigms

I loved stack based programming, functional programming, thinking in excel
(data flow). There is no one solution to everything.

\- domain specific languages

Learn to make them, it is fun and an extremely powerful tool in the
programmers toolbox.

\- parsers

Don't be afraid of them, they are your friend. And often easier than regexes.

\- learn how to search

Big skill, not everybody does this right.

\- Programming notebooks

Why is this not standard? Mathematica is brilliant with this and while I don't
like python, but jupyter is very good.

\- IDE's

They are useful. Don't be vain.

\- Make designs

Plan what you are going to make. That helps a lot.

\- Property style testing

Checkout quickcheck ^_^

That is my list. It is not exhaustive.

------
ericol
"a much better programmer" != "much more productive" (At least from my point
of view)

I'm going to answer on the latter, because I can't say if I'm a much better
programmer than, say 5 years ago (But I blame that to the fact that the
product I develop is "frozen" and I don't do much than small bug hunting and /
or forensics when something goes wrong; or "janitoring" as I refer to it
nowadays).

In no particular order, these are the tools that over the years have made my
life incredible easier and let me focus on the problem at hand, and not
solving the problems I had to deal before solving the problems I had to solve:

1\. Git. 12 years ago, I was the sole developer at my company, and I had to
strong arm my boss (And company owner) to ditch CVS for Git. Probably one of
the best company decisions I was responsible off (Being the next one getting
the company on Slack)

2\. xDebug. When I discovered xDebug (PHP) my life changed overnight. As I
said I don't do much coding these days. When I was full on coding, I had
hacked a way to be able to work with xDebug with a small class made
specifically for debugging, that allowed me to do "code hot reload" until I
hammered my code in place.

3\. Any tool by JetBrains. I have a lifetime licence for PHPStorm 2016.x (You
get that after paying the license for a year). And I currently am a paying
customer of WebStorm. I plan to keep paying for it until I make it to the
year, because then you get a lifetime license. I know IDEs and editors are
bound for flame wars, but honestly, for people like me that are not really
invested in getting an expert command of their tools, JetBrains gets you the
most bang for your money right out of the box.

4\. Virtual box, then Vagrant, and these days docker. Virtualization for me
was the best way to fix the "but it works on my box" syndrome some 10 years
ago. I discovered VBox and then vagrant, and I've been a happy customer for
years. I've been eyeing docker for some time now and the quarantine gave me
the time to investigate it on my own. With VBox / Vagrant I had the problem
that when moving I had to move large archives for the different disks I had
accumulated over the years. Now with docker I just need to move the data, the
code, and the docker file that builds the container that I use. I also use
docker to learn other things like node and python. For python I've been using
Miniconda for some time, but I didn't like the way it handles - nor had the
time to learn how to correctly - environments. Same with node and the
node_modules hell. With both, I use small set up files where I store a default
configuration so whatever package I get is saved on shared volumes on my
machine, and the same on code. That way I decide what to share where, and
getting rid of something is as easy as removing a folder.

5\. Linux. I started learning me some Linux when I started this job 13 years
ago, and over the years it grew on me. Last year my notebook disk gave up, and
when I changed it I installed Debian on it. This year the same happened to my
desktop box, and I did the same. Even thought there are programs that I do
miss from Windows the reality is that many of them I can run with Wine, and
the others get replaced for something else that is, if not better, at least on
par with their Window counterparts. And I keep finding tools that are
incredible awesome (Like mpv for video playing)

------
inetknght
\- Regex. I don't think anyone's a true developer until they've mastered using
regex where globbing would be used. Using regex for globbing is an excellent
place to start learning.

\- Unit testing. No true developer can call themselves such until they can
programmatically verify that their code works to some explicit specification.

There's tons of other things that are bonus points. But I wouldn't call anyone
a true developer until they understand and use both of those.

------
anonu
kdb/q: its a programming language more than a tool. But learning it has made
me more efficient in other languages. It's vector approach to programming
makes me think about how to leverage similar features in python for example.
itertools library in Python is mostly inspired by APL, an ancestor of q

------
Deely123123
Still no mention of clipboard manager?

------
srachamim
All of the following made me a better programmer:

1) Functional Programming

2) VIM

3) Kinesis Advantage

4) tmux

Really, I can't think of programming without those four tools.

------
aaronblohowiak
Three books:

* Nonviolent Communication

* Crucial Conversations

* Writing Without Bullshit

------
Joeboy
In recent years:

1) Ripgrep

2) Upgrading my Lenovo T430 laptop to a P53

~~~
ufo
My only beef with ripgrep is that "rg" is only a small typo away from "rm".

One time I almost deleted my working directory but luckly I had passed the -i
flag for case insensitive search :)

~~~
mxuribe
Have you considered creating an alias - such as "rip" or "grrr" \- for using
ripgrep to help avoid that concern of rg vs rm?

~~~
ufo
The "rm" thing was only (almost) a problem that time because I had passed a
list of files to ripgrep, instead of passing it a list of directories to do a
recursive search. rm by default don't erase directories.

But now that you mention it, creating an alias gr=rg sounds like a no-brainer.
Thanks.

------
smcameron
stgit Kind of like quilt on top of git. It lets you keep a lot of balls in the
air all at once with very little effort.
[http://www.procode.org/stgit/](http://www.procode.org/stgit/)

------
morphar
Doing lots of small test or benchmark programs to better understand how the
language works.

------
antipaul
Focusing on "more efficient" in "better":

\- emacs: works for me to code in R, python, connect to remotes, etc

\- keyboard shortcuts: got started with them early, and never looked back.
Bonus: linux/macOS/emacs text navigation works across all of them (ctrl-f,
ctrl-b, ctrl-a, ctrl-k, alt-delete, etc)

\- git: managing file versions and file diffs (!)

\- GitHub: terrific for project management, even when I'm the only one on the
project ;)

\- CLI utilities that I love:

    
    
        - ag, a better "grep"
        - fd, a better "find"
        - tldr, a better "man"
    

My dotfiles and new box setup:
[https://github.com/pavopax/dotfiles](https://github.com/pavopax/dotfiles)

CLI tools:

[https://github.com/ggreer/the_silver_searcher](https://github.com/ggreer/the_silver_searcher)

[https://github.com/sharkdp/fd/](https://github.com/sharkdp/fd/)

[https://github.com/tldr-pages/tldr](https://github.com/tldr-pages/tldr)

EDIT: formatting

~~~
antipaul
... then, for data science tasks, these were a revelation:

\- R's dplyr and wider tidyverse \- python scikit-learn

They are terrific APIs that, after I've gained deep familiarity from
experience, are literally a joy to use for me and feel like I've "leveled up"
(way up)

------
ranyefet
For me it’s definitely Elixir

~~~
juliend2
Interesting. Why? What does it have (or haven't) that made you a better
programmer?

------
codemac
Well, it's certainly not tools that let me _add_ lines of code.

------
smonff
Tmux, Emacs, Perl, jQuery.

------
sailfast
An automated test suite with snapshots and contracts for data.

------
dm03514
* version control

* static typing (golang)

* unit tests

------
purplezooey
Wait I thought everyone was switching to dwm now..

------
0xEFF
xargs! Instant concurrency for small scripts.

~~~
christiangenco
Could you go into more detail about how you're using xargs? I'm having trouble
understanding how it can be used for concurrency.

~~~
detaro
xargs --max-procs _N_ (or -P _N_ ) starts up to _N_ instances of the called
program in parallel, at least with GNU xargs.

------
runnr_az
The linter has been my best programming coach.

------
ltr_
fzf tmux Vim+plugins+ language servers. lldb/gdb, languages repl's in
general(ie. ghci for haskell)

------
charlesdaniels
* AWK - I read "The Awk Programming Language"[0] cover to cover. It's a very well written text, and it not all that long. The examples are very impressive. In terms of bang-for-the-buck of learning tools, AWK has definitely given me the most mileage. I probably use it at least a dozen times a day just for little things. However, you can wield it to write some very powerful scripts in very short amounts of time.

* Make - I use Make for almost every project I write, even if the rules are just .PHONY shortcuts. Make solves a huge set of problems relating to the order in which things need to be run/built very well. There are arguable better tools, but Make is widely deployed, widely used, widely understood, and solve the problem well enough for a _lot_ of small to medium projects (and some large ones too!). I got asked about it enough that I wrote an introductory guide for it[1] (disclaimer: self promotion of my own site, but I don't have any ads or make any money). If you feel like Make has a lot of legacy crust built up over the years, you should read[2].

* Graphviz[3] - a huge number of ad-hoc data structures that you will build for your projects can be hard to visualize, Graphviz makes it easier. One tactic I've found useful is to loop over nested structs using their memory address as the identifier in Graphviz, struct fields as text annotations, and nested struct pointers as outgoing links. This might sound fancy, but you can probably write an export_to_graphviz() function for your project in under 50 lines of C. Because the syntax is simple, it's very easy to generate Graphviz from pretty much any language out there.

* Xpath - if you've ever wanted to do even simple web scraping or XML parsing, do yourself the favor of learning Xpath. It's a very powerful way of querying XML-like documents. I learned it by writing bots in Selenium for an internship, but nowadays I mostly do very simple web scraping for personal projects. To that end, I wrote a little tool[4] to grab the contents of a page, run a query, and print the results out on the console.

* Not a tool per se, but pick some kind of "personal knowledge management" type of solution and use it religiously. I like Joplin[5], but there are a million out there (Evernote, OneNote, ZimWiki, TiddlyWiki, VimWiki, Emacs Org-Mode, and many, many more). Being able to refer to earlier notes is invaluable for long-running projects.

* Also not very specific - learn the scripting language for your platform. In UNIX-land that's sh (or Bash), and in Windows that's PowerShell. Bash and PowerShell both have benefits and drawbacks, and you probably shouldn't write "real programs" in either. But knowing how to script whatever platform you're using buys you a lot.

* One more, also non-specific one - learn an interpreted language. Nowadays people like Python, but Perl, TCL, Lua, JS, and others could all be valid choices. These are great for prototyping ideas that you will later port to the language you really use (if it isn't on that list already), or for writing little tools or utilities for yourself to use. Which one you choose will depend on what library ecosystem is most relevant to your work.

0 - [https://www.amazon.com/AWK-Programming-Language-Alfred-
Aho/d...](https://www.amazon.com/AWK-Programming-Language-Alfred-
Aho/dp/020107981X)

1 - [http://cdaniels.net/2017-07-15-guide-to-
make.html](http://cdaniels.net/2017-07-15-guide-to-make.html)

2 - [https://tech.davis-hansson.com/p/make/](https://tech.davis-
hansson.com/p/make/)

3 - [https://graphviz.org/](https://graphviz.org/)

4 - [https://git.sr.ht/~charles/charles-
util/tree/master/bin/quer...](https://git.sr.ht/~charles/charles-
util/tree/master/bin/query-webpage)

5 - [https://joplinapp.org/](https://joplinapp.org/)

------
lobo_tuerto
* Linux

* i3

* git

* Elixir (functional programming concepts)

------
agumonkey
magit

------
acln
perf and pprof.

------
tarrsalah
Emacs, Magit.

------
heldrida
Git and grep!

~~~
Joeboy
I use ripgrep (`rg`) much more than I use grep now. Wish I'd discovered it
sooner.

~~~
mxuribe
Oh yeah, 100% this!

------
seymores
Postico

------
metreo
Linux

------
MidnightRaver
PyCharm

------
4g3ntS33
Node Red

------
adultSwim
Listening

------
andrewstuart
Pycharm

------
sys_64738
Emacs.

------
herve76
Github

~~~
zadkey
Grubhub

------
holri
Free Software

------
nojito
So much useless information in this thread.

The best way to become a better programmer is to read more code and understand
what it does and think about different ways to implement the same feature.

Programming is problem solving at its core. Everything your mentioning is
secondary to achieving that goal.

~~~
karamazov
You're right, let's go back to punchcards.

