27 ms·

Ask HN: Which tools have made you a much better programmer?

• pirsquare 6y ago
  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 6y ago
    What color scheme helps with looking at my spouse? Ba dum tss!
• randylahey 6y ago
  Choice of editor is subject to taste, but I find VI/Vim keybindings and modal editing an absolute must-have for productivity.
  • entropicmind 6y ago
    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 6y ago
      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.
    • jmchuster 6y ago
      For those non-viers out there, the analogous option in non-modal editors like, say, sublime, would be `select all => split into lines` or `column selection`.
  • pedrogpimenta 6y ago
    Yes, I learned vim recently because I was far-away with a shitty netbook and a project fell into my hands. Having a shit computer, a modern dev environment wouldn't work, so I learned a lot of vim while coding it. Nowadays I'm using VSCode because it has many many features not available on vim (or available with plugins with a large learning curve that I can't have right now) but I always use vim mode. I can't imagine not being able to navigate like vim and have now added vim-like bindings/commands to some other programs like Firefox.
  • daveevad 6y ago
    +1 and a recommendation for vimium browser extension. basically, whatever allows increased rate of I/O between you and a computer. it's really as simple as never leaving the home row and im pretty close to thinking that the mouse as an input device has held people back.
    • chiefsucker 6y ago
      +1 When you’re on it, also install Vimac [1]. I’ve mapped it to ⌃Space (similar to Spotlight’s ⌘Space). It’ll make you grab the mouse / trackpad less often. [1] https://github.com/dexterleng/vimac/ https://github.com/dexterleng/vimac/
• hprotagonist 6y ago
  intellisense and friends. As a junior developer, method documentation and autocomplete on demand are crutches i leaned on VERY heavily with great success.
• anarchyrucks 6y ago
  GDB.
• zeroxfe 6y ago
  - 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.
  • xcubic 6y ago
    Would you go into details about the one step deployment?
    • zeroxfe 6y ago
      I usually have a shell script called 'deploy.sh' that does a bunch of git, test, deploy stuff. So part of my development workflow is calling "deploy dev", "deploy staging", and/or "deploy prod" to push any changes to the dev/staging/prod environments. The script makes sure changes are tagged, committed, and pushed, tests pass, builds and pushes container images, static files, and then rolls out binaries. The rollouts depend on the infrastructure -- it could be something like scp + kill/restart, or a kubectl command, or "gcloud run deploy", etc. One-step deployments vastly improve the quality of the service because I can test things in real environments quickly, push out patches and bug fixes quickly, keep updates small and bounded, and bonus, I can come back to a codebase months later and not have to re-learn how to roll something out.
      • xcubic 6y ago
        For a while I used pm2 to deploy stuff. It's honestly a nifty little tool but I'm moving away into a docker based solution. Initially I was thinking into having a CI build the images and push it to the server and so one but for my personal projects, it's too much. So I might just do a bash script to build the image, push it to the hub and then connect to ssh to pull the image and restart. Regarding your script, could you share a template?
  • nickysielicki 6y ago
• rb808 6y ago
  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.
• morphar 6y ago
  Doing lots of small test or benchmark programs to better understand how the language works.
• runnr_az 6y ago
  The linter has been my best programming coach.
• nickysielicki 6y ago
  * `perf top` * `scan-build` * https://github.com/pwndbg/pwndbg https://github.com/pwndbg/pwndbg, a very comprehensive gdb extension/config.
• toastal 6y ago
  Learning how to use type holes has really helped a lot in recent years. Learning how to grok documentation and source code as well.
• daenz 6y ago
  - 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)
• inetknght 6y ago
  - 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.
• dgb23 6y ago
  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.
  • dvdt 6y ago
    I completely agree with the point about integrated REPL/IDE, and wanted to share some of the combinations I have used in the past, since it can be a concrete getting started point for those who are curious. Some of these are not literally repls, but IMO give a similar experience. - ClojureScript with Figwheel and the web browser - Clojure with Emacs Cider, Clojure with Cursive - R and Rstudio - Matlab - ipython jupyter notebook - Pycharm debug breakpoints that are triggered by unittests (Running the unittest to initiate a python repl at the breakpoint)
    • mxschumacher 6y ago
      What I really love about R/Rstudio is that you can highlight a few lines of code and execute them in isolation
  • jimbokun 6y ago
    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.
• vitorbaptistaa 6y ago
  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.
• sam_lowry_ 6y ago
  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 6y ago
    Any recommendations for resources on learning more about these commands?
    • ravoori 6y ago
      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-MgN0H1joIoDVoIC7/The_AWK_Programming_Language.pdf https://ia802309.us.archive.org/25/items/pdfy-MgN0H1joIoDVoI...) 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)
    • ChanderG 6y ago
      https://www.grymoire.com/Unix/index.html https://www.grymoire.com/Unix/index.html Have used this for Awk and Sed.
• heldrida 6y ago
  Git and grep!
  • piinbinary 6y ago
    and `git grep` :)
  • Joeboy 6y ago
    I use ripgrep (`rg`) much more than I use grep now. Wish I'd discovered it sooner.
    • mxuribe 6y ago
      Oh yeah, 100% this!
• dugword 6y ago
  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 6y ago
    Yeah, I still use perl for most all the server side stuff I have to do.
• throwawaygo 6y ago
  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.
• zenlot 6y ago
  Emacs. Specifically Doom Emacs. https://github.com/hlissner/doom-emacs https://github.com/hlissner/doom-emacs
  • kleiba 6y ago
    Emacs. Specifically vanilla GNU Emacs. https://www.gnu.org/software/emacs/ https://www.gnu.org/software/emacs/
• itqwertz 6y ago
  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 6y ago
    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 6y ago
      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.
      • abiro 6y ago
        I used to work on MBPs and then switched last year to a Thinkpad X1E running Mint and I couldn’t be happier. Do make sure though to search for potential problems for the specific Thinkpad model that you pick. (And spare a few dollars to support Mint development if you choose it and can afford it!)
      • andrefuchs 6y ago
        I'm using Ubuntu on a ThinkPad x230. Works flawlessly for years.
      • iimblack 6y ago
        In general, Thinkpads work great with Linux. You'll want to check your specific model though, especially if you're buying a version that's just been released.
      • Joeboy 6y ago
        Running Ubuntu 20.04 on my P53. The Internet told me I needed to check the BIOS was up to date and check a couple of things were set properly before installing, which I did, and everything seems fine. Before that it was a T430 which was also fine.
• robbyt 6y ago
  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.
  • tudorpavel 6y ago
    Could you expand on the Ruby part? I'm not sure if you hate all programming or programming in anything other than Ruby.
  • metapsj 6y ago
    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 6y ago
      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 6y ago
        What are your thoughts on Crystal? See: https://crystal-lang.org/ https://crystal-lang.org/
        • ativzzz 6y ago
          It's ruby but with extra steps
• Jeaye 6y ago
  - 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/950300ff8120950814879a46b796b3c7 https://gist.github.com/jeaye/950300ff8120950814879a46b796b3... ) - 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.
  • nivethan 6y ago
    For a very long time I didn't use anything besides just plain vim, 2 biggest things to add to your vim use is undodir and YouCompleteMe. Crazy that I didn't have either of these for so long, undodir I wish was part of the default.
    • Teichopsia 6y ago
      New(ISH) vim user here. I couldn't figure out how to install YouCompleteMe the other day, but I had not trouble with coc.
    • necrotic_comp 6y ago
      To add to this, vim quickfix-reflector ( https://github.com/stefandtw/quickfix-reflector.vim https://github.com/stefandtw/quickfix-reflector.vim) was life-changing for me. It lets you modify and save code from the quickfix buffer, so when you search for something and it shows up in the qf, you can do a find replace / edit / etc. This is especially great for mass refactoring / renaming.
      • 6y ago
• herve76 6y ago
  Github
  • zadkey 6y ago
    Grubhub
• city41 6y ago
  Here is a similar conversation from about a month ago: https://news.ycombinator.com/item?id=23118940 https://news.ycombinator.com/item?id=23118940
• scanr 6y ago
  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.
  • hinkley 6y ago
    The way I've seen the 'better software' show for myself is that I see problems that people walk away from that are just too complex or diffuse and their priorities just don't make it worth the struggle. Tools that eliminate even a little bit of cognitive load moves the point of no return a little bit farther, which means there are kinds of problems you can touch that someone else won't or can't.
  • SkyPuncher 6y ago
    Unbelievably amazing to be able to shift-click on syntax and jump to the source - even works pretty well in dynamic languages. I HATE using a Gem then needing to break my train of thought to pull up the official documentation to see what an API interface looks like. Ctrl+click. In and out in 15 seconds.
    • kortex 6y ago
      You just taught me something! I've been using keyboard hotkeys to jump to source. On mac, I can hold down command (probably ctrl on linux) and it lights up like a link, shows the gist, and let's me click to go to source. This is why I love these sorts of threads :)
      • abhijat 6y ago
        Ctrl-B also goes to definition (at least on Linux) if you don't want to leave the keyboard. On definition Ctrl-B lists all usages of the term under caret.
    • mekster 6y ago
      After a while, you'd think why this isn't the default in other editors. (At least VSCode jumps to obvious sources.)
• tonyedgecombe 6y ago
  ReSharper, I probably wouldn't have got around to understanding LINQ without its regular prompts.
• piinbinary 6y ago
  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 6y ago
    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.
  • smitty1e 6y ago
    Spacemacs! But also, writing the documentation as one works through the problem, either in org-mode, or in a wiki. The older I get, the less I remember, so the documentation is key.
  • auslegung 6y ago
    I'd love to get better at quickly understanding an unfamiliar codebase. Do you have any resources I could dig into?
• oblib 6y ago
  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.
• huhtenberg 6y ago
  assert() that is not compiled away in release builds. A miracle discipline drug that makes people think through what they are trying to code.
• dm03514 6y ago
  * version control * static typing (golang) * unit tests
• ydnaclementine 6y ago
  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
• ericol 6y ago
  "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)
• majormajor 6y ago
  - 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
• kirstenbirgit 6y ago
  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.
• furstenheim 6y ago
  - 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 6y ago
    `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.
• brightball 6y ago
  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.
• smitty1e 6y ago
  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.
• codemac 6y ago
  Well, it's certainly not tools that let me add lines of code.
• benjohnson 6y ago
  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
  • smitty1e 6y ago
    But. . .then. . .how. . .did you get to this site?
    • benjohnson 6y ago
      :) I have a dedicated "time-wasting" computer - this helps me recognize when I'm spending too much time doing things that may not be important.
  • AdrianB1 6y ago
    Lol, same for Facebook here. I don't have an account (I had one years ago), but the Internet is full of FB links. Considering doing the same for Twitter, even if I never used it (it is not so popular in Europe).
  • diehunde 6y ago
    I waste time when I go to YouTube because of all the recommendations I get. I added custom css to Safari and added display: none to all those divs so now I never see recommendations and just watch the thing I'm looking for.
  • mxschumacher 6y ago
    for good measure, here are 83k additional domains: https://github.com/StevenBlack/hosts https://github.com/StevenBlack/hosts
  • boterock 6y ago
    I've been using the Leechblock extension on Firefox. It lets you set browsing quotas per website. It has been good for reducing time wasting habits.
  • sneeuwpopsneeuw 6y ago
• lstamour 6y ago
  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-O43G5VnJ0_CB8C&feature=share https://www.youtube.com/playlist?list=PL2miG2CzrxakbZswQH-O4... 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-methods-and-applications https://mitpress.mit.edu/books/design-structure-matrix-metho... 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.
• Deely123123 6y ago
  Still no mention of clipboard manager?
• hinkley 6y ago
  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 6y ago
    +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 6y ago
      +1 to self code reviews, I almost always find stuff I've missed or could have done better.
      • kyleashipley 6y ago
        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.
• typenil 6y ago
  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 6y ago
    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
• agentultra 6y ago
  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.
• MrQuincle 6y ago
  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. :-)
• 0xEFF 6y ago
  xargs! Instant concurrency for small scripts.
  • christiangenco 6y ago
    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 6y ago
      xargs --max-procs N (or -P N) starts up to N instances of the called program in parallel, at least with GNU xargs.
• revskill 6y ago
  To me, it's functional programming in general and Haskell specifically. Thinking in function actually helps me become a better programmer !
• stared 6y ago
  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 6y ago
    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.
• kushalpandya 6y ago
  StackOverflow (and Stack Exchange network in general).
• arc_of_descent 6y ago
  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!
• jamespetercook 6y ago
  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.
• antirez 6y ago
  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.
  • cursork 6y ago
    Absolutely this. When facing a tough problem it’s a great tactic to write out what you’re trying to solve and how you plan to solve it in prose-style English. I’ve done it often without ever sharing my writings with anyone at all, and always felt that the code turned out relatively good as a result. I’d also add that a very prototype that you throw away also helps line up your thoughts. The key is having something reasonably concrete in front of you that forces you to think of the invariants, compromises, etc in the system. Before making all those decisions concrete by writing loads of code
  • throw1234651234 6y ago
    This is the most useful post so far. I take it a step further and make a diagram in draw.io to understand exactly the data that is coming in and out. This is especially important for working with legacy code where you might get random crap like a name instead of an id and that could throw off your design.
    • mxschumacher 6y ago
      here is another useful tool to draw graphs/flowcharts: https://whimsical.com/ https://whimsical.com/
  • andreygrehov 6y ago
    I'm trying to be better at this. Any examples/recommendations you could share?
    • ianamartin 6y ago
      Not sure if this is what antirez had in mind, but when I'm working on stuff, I whiteboard (if I'm at home--and who isn't these days) or write in a notebook. First thing I figure out is how I want to interact with a thing. Whether that's a program or a class or a function. How do I want to call it? What parameters do I want to pass? What do I want it to return? How do I want to use what it returns? So, basically, write the interface first. If I'm building something with multiple parts rather than a single class or function, I'll map out how these things all work together. A loose graph of interactions. Invoke A and have it return X; invoke B and pass X to it and it returns Y; etc. Then I'll consider failure modes and think about what should happen if something doesn't work out quite right. Is it possible to route failures to a centralized cluster of error handlers so I don't have to implement error handling at every level? Finally, I'll think about whether I can map behaviors to defined data structures instead of controlling flow with if/else patterns. Once I have all that written down or mapped out, then I'll start implementing from the outside in. Stub the object, methods and return dummy data structures that fit until I have a complete system that's interacting the way I want. Then I go in and implement the actual functionality I need. The last part--implementing functionality--often implies modifications to my initial thought process. But it's easier to understand what those changes affect if you've already mapped your design. So you might think B can produce Y with I parameter. Maybe it turns out you can't. So now you need to add a new param. Where is that going to come from? Well, you don't have to invent that out of nowhere because you've already mapped out what is happening. You know that you need to either add another node to the call graph or change the return value somewhere else. By the end of the process, you have a working program, and you've also done a lot of your documentation work as well. Again, I have no idea if this is what anyone else is talking about here. But this is how I personally work. It annoys the hell out of some people. But it works for me and helps me create sane software with interfaces people can remember over time.
• UYChuH 6y ago
  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 6y ago
    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.
• gregwchase 6y ago
  Docker. Being able to develop/ deploy code across a team and business is invaluable.
  • cowmix 6y ago
    100%.. for all the crap Docker gets these days, it has been a great tool for my software dev processes.
    • blandflakes 6y ago
      I don't mean this as a counterargument, but I've become much more efficient now that I've been able to leave docker behind (changed jobs). Docker solves some real problems, but it had real costs for me.
    • takeda 6y ago
      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.
• Joeboy 6y ago
  In recent years: 1) Ripgrep 2) Upgrading my Lenovo T430 laptop to a P53
  • ufo 6y ago
    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 6y ago
      Have you considered creating an alias - such as "rip" or "grrr" - for using ripgrep to help avoid that concern of rg vs rm?
      • ufo 6y ago
        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.
• tkainrad 6y ago
  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.
  • GuB-42 6y ago
    For zsh, I highly recommend zsh-histdb, it stores all your commands in a sqlite database, along with data like timestamp, current working directory, hostname, session id, etc... It has its own "histdb" command but the best part is that it integrates well with zsh-autosuggestions, so with the right SQL query you can make it suggest something "the latest command in the current session that matches, or if not found, the most frequent in that directory". I know it is controversial because it is not using a text file and UNIX loves text files, but it really nice, and you still have your .zsh-history if you want to.
    • kortex 6y ago
      histdb is one of my top favorite tools. And I've come to the conclusion flat files can only get you so far. sqlite is probably the next best thing to flat files, and I think history is one of those things where switching to a db is an immediate win.
  • dukeofharen 6y ago
    Wanted to thank you for writing your blog post. I have been on Linux full-time since about july 2019 and found your post some time after that. Your post really kickstarted my productivity in Linux.
• acln 6y ago
  perf and pprof.
• agumonkey 6y ago
  magit
• p4l4g4 6y ago
  - 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 6y ago
    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 6y ago
      > 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.
• chad_strategic 6y ago
  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 6y ago
    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.
  • I_am_tiberius 6y ago
    I don't know Navicat but I use DBeaver and am super happy.
• flohofwoe 6y ago
  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 ;)
• sailfast 6y ago
  An automated test suite with snapshots and contracts for data.
• eitland 6y ago
  - 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
• axegon_ 6y ago
  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 6y ago
    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).
• easterncalculus 6y ago
  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 6y ago
    Guess an ergonomic keyboard could help prevent some injuries.
• tchaffee 6y ago
  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 6y ago
    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?
    • rovr138 6y ago
      Not who you asked, but I use it to test things out. You can export the notebook to code. You can comment out code or refactor then on your IDE or just copy & paste once it's working into a function/method. I also know some people that just need to run things every now and then and they just launch the notebook and run it.
    • tchaffee 6y ago
      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
• fosspowered 6y ago
  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 6y ago
    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 6y ago
      There is a JetBrains extension too!
• vmchale 6y ago
  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.
• AdrianB1 6y ago
  - 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 6y ago
    There is a paid version of VS Code?
    • AdrianB1 6y ago
      Visual Studio is paid. I don't qualify for the Community Edition, all other editions are paid.
      • dunefox 6y ago
        Visual Studio Code and Visual Studio are two completely different things.
    • Chickenosaurus 6y ago
      Maybe the person meant to say Visual Studio Code is preferable to Visual Studio.
      • wenc 6y ago
        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/
• nojito 6y ago
  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 6y ago
    You're right, let's go back to punchcards.
• cstuder 6y ago
  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 6y ago
    +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.
• romes 6y ago
  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 6y ago
    If you're using Windows 10, you already have this: press Windows-v. The clipboard can also be shared across your Windows devices.
  • majkinetor 6y ago
    CopyQ is MUCH better & cross platform.
• holri 6y ago
  Free Software
• zoomablemind 6y ago
  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.
• edpichler 6y ago
  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.
• idoby 6y ago
  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.
• lobo_tuerto 6y ago
  * Linux * i3 * git * Elixir (functional programming concepts)
• louib 6y ago
  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.pdf https://catonmat.net/ftp/bash-vi-editing-mode-cheat-sheet.pd...
  • mierz00 6y ago
    Holy shit. Thank you.
  • jmchuster 6y ago
    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
    • zmmmmm 6y ago
      All of those require me to shift my hands away from the home row of the keyboard though. The real magic of vi-mode is that everything you need is right there under your fingertips 100% of the time. Well, except escape, but that is why I map caps-lock to escape ...
      • jmchuster 6y ago
        Ah, interesting. That's something I've never even considered before. My hands seem to just move naturally back and forth without thinking. I know that people have brought up having to move back and forth between keyboard and mouse as being a pain point, but never thought about having to move out of the home row as one as well. For me, moving back and forth between keyboard, touchpad, mouse just seems second nature. I do wish I was better at dual-wielding keyboard and mouse, though, so I've been looking into mirrorboard.
• fouric 6y ago
  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).
• princevegeta89 6y ago
  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/id876540291?mt=12 https://apps.apple.com/us/app/copyem-paste-clipboard-mgr/id8... This is a great clipboard manager and helps a lot with Copy-Pasting.
• MidnightRaver 6y ago
  PyCharm
• efferifick 6y ago
  * fuzzers https://blog.regehr.org/archives/1687 https://blog.regehr.org/archives/1687
• cosmotic 6y ago
  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)
• heinrichhartman 6y ago
  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.
• jordanpg 6y ago
  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 6y ago
    Interesting... Does something like this exist for Excel? Asking for a friend (seriously).
• catears 6y ago
  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 6y ago
    In the same vein as silver searcher, I'd mention ripgrep: https://github.com/BurntSushi/ripgrep https://github.com/BurntSushi/ripgrep
• wozer 6y ago
  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-testing/ https://fsharpforfunandprofit.com/posts/property-based-testi...
• code-faster 6y ago
  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.
• pinopinopino 6y ago
  - 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.
• deleted 6y ago
  [deleted]
• voldybot 6y ago
  https://fishshell.com/ https://fishshell.com/
• vmception 6y ago
  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.
• sys_64738 6y ago
  Emacs.
• deleted 6y ago
  [deleted]
• sandermvanvliet 6y ago
  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
• mellosouls 6y ago
  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 6y ago
    Took me awhile, but (here it is) [https://copernic-desktop-search.software.informer.com/download/ https://copernic-desktop-search.software.informer.com/downlo...].
    • mellosouls 6y ago
      I assume they are the same ones as available through the website? https://www.copernic.com/en/products/desktop-search/previousversions/ https://www.copernic.com/en/products/desktop-search/previous... 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-nasty-downgr/ https://pinkeyegraphics.co.uk/copernic-desktop-search-3-a-na... 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.
• smcameron 6y ago
  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/
• ranyefet 6y ago
  For me it’s definitely Elixir
  • juliend2 6y ago
    Interesting. Why? What does it have (or haven't) that made you a better programmer?
• teknopaul 6y ago
  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.
• easymovet 6y ago
  QBasic, everything since then has been incremental.
• jtolmar 6y ago
  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 6y ago
    By layers, do you mean interfaces and abstract layers?
    • jtolmar 6y ago
      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.
• kartayyar 6y ago
  Bazel. I really like the workflow of how it only selectively runs unit tests.
• edw 6y ago
  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.
• Pabblo001 6y ago
  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
• nh2 6y ago
  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-syscall.html http://www.brendangregg.com/blog/2014-05-11/strace-wow-much-..., 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).
  • heleninboodler 6y ago
    strace is the first thing I skimmed down the thread for. You can learn a lot about how things work (or aren't working) by getting really familiar with an strace. Some of my coworkers give me grief for how easily I jump to "let me see an strace" but it works.
  • patrec 6y ago
    Do not use strace. Use sysdig which is superior in just about every way.
    • stonogo 6y ago
      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.
• rozgo 6y ago
  Apple II, TRS-80. Quake engine. Haskell, F#, Rust. Type theory, domain and test driven design. Philosophy, economy. Linux. Physics engines, PyTorch, GStreamer. Twitter.
• jschulenklopper 6y ago
  Touch typing - learning it during this WFH phase, as much more communication is done typing.
• dcchambers 6y ago
  - 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 6y ago
    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-Protocols https://git-scm.com/book/en/v2/Git-on-the-Server-The-Protoco... - https://git-scm.com/book/en/v2/Git-Internals-Plumbing-and-Porcelain https://git-scm.com/book/en/v2/Git-Internals-Plumbing-and-Po...
• kashfi 6y ago
  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.
• austincheney 6y ago
  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.
• kortex 6y ago
  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 ;)
• darkport 6y ago
  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.
• charlesdaniels 6y ago
  * 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/dp/020107981X https://www.amazon.com/AWK-Programming-Language-Alfred-Aho/d... 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/query-webpage https://git.sr.ht/~charles/charles-util/tree/master/bin/quer... 5 - https://joplinapp.org/ https://joplinapp.org/
• shruubi 6y ago
  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.
• keithnz 6y ago
  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.
• schwartzworld 6y ago
  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.
• bconnorwhite 6y ago
  Extra RAM for your brain - whiteboard film surface on your desk + 4 monitors.
  • jaredtn 6y ago
    Interesting. How does that work when you want to rest your forearms while typing?
    • PTOB 6y ago
      Plot twist, user has no arms.
• rco8786 6y ago
  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.
• sushshshsh 6y ago
  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
• haidrali 6y ago
  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.
• Agentlien 6y ago
  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.
• Shicholas 6y ago
  New Relic, APM is important, and grokking this or a similar tool (Datadog, AppDynamics, Solarwinds) can only make you much more productive.
• aaronblohowiak 6y ago
  Three books: * Nonviolent Communication * Crucial Conversations * Writing Without Bullshit
• andrewstuart 6y ago
  Pycharm
• bttrfl 6y ago
  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.
• spaetzleesser 6y ago
  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 6y ago
    Regular scheduled 1:1 meetings with those I work closely with. Does wonders for teamwork / relationship building.
• brailsafe 6y ago
  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.
• amirathi 6y ago
  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 6y ago
    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 6y ago
      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.
  • afarrell 6y ago
    It is even better if you draw diagrams on dotted paper while you read.
• smonff 6y ago
  Tmux, Emacs, Perl, jQuery.
• pathartl 6y ago
  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.
  • Artlav 6y ago
    I'm really confused by this. Don't debuggers come embedded into any IDE worth using? How could someone start programming this century without access to one?
    • pathartl 6y ago
      In the PHP world I'd argue most developers don't use an IDE, let alone a debugger. Setting a debugger up with Xdebug or ZendDebugger is also not easy for those less experienced with setting up the actual PHP environment.
  • thewebcount 6y ago
    So much this. And command-line debuggers are usually awful. Just being able to set a breakpoint in the actual text file you're editing without using a different tool, and stop when a condition happens can speed up your workflow so much.
  • maerF0x0 6y ago
    +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 6y ago
• nurettin 6y ago
  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 6y ago
    I second this. Also, whiteboard notecards and neodynium magnets.
• ninjakeyboard 6y ago
  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.
• jimmaswell 6y ago
  IDE features may be my biggest productivity boost.
• jb3689 6y ago
  - 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
• thewebcount 6y ago
  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.
• graton 6y ago
  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 6y ago
    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 6y ago
      exa completely breaks ls arguments/switches and as such is a hard pass for me.
      • mxschumacher 6y ago
        I have since switched to lsd: https://github.com/Peltoche/lsd https://github.com/Peltoche/lsd
• ltr_ 6y ago
  fzf tmux Vim+plugins+ language servers. lldb/gdb, languages repl's in general(ie. ghci for haskell)
• antipaul 6y ago
  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 6y ago
    ... 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)
• justsomeuser 6y ago
  - 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.
• l0b0 6y ago
  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 6y ago
    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 6y ago
      https://gist.github.com/l0b0/b655d155c5cfc509c339cd0b1cd494cf https://gist.github.com/l0b0/b655d155c5cfc509c339cd0b1cd494c... 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.
  • bootlooped 6y ago
    I have a coworker I pair program with a lot who is a member of the VIM religion. But when we need to refactor something it's "let's use you editor (GoLand) for this".
• the_pwner224 6y ago
  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?).
  • bransonf 6y ago
    Similarly, Kite [0] for Python and JavaScript. I actually prefer Kite to TabNine, but ymmv. [0] https://kite.com/ https://kite.com/
    • j88439h84 6y ago
      Kite got criticism for tracking and injecting ads. https://qz.com/1043614/this-startup-learned-the-hard-way-that-you-do-not-piss-off-open-source-programmers/ https://qz.com/1043614/this-startup-learned-the-hard-way-tha...
  • gitgud 6y ago
    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
    • esperent 6y ago
      It uses _so_ much memory. I recently added an extra 16gb stick to my laptop, maybe I'll give it another try.
• simonw 6y ago
  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.
• simonw 6y ago
  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.
• erichurkman 6y ago
  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.
• snypox 6y ago
  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 6y ago
  FinderPath[0]. It taught me what macOS looks like in its fs. [0] https://bahoom.com/finderpath/ https://bahoom.com/finderpath/
• allworknoplay 6y ago
  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.
• 1e-9 6y ago
  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)
• desc 6y ago
  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.
• openfuture 6y ago
  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.
• erikerikson 6y ago
  https://en.m.wikipedia.org/wiki/AspectJ https://en.m.wikipedia.org/wiki/AspectJ
• vesinisa 6y ago
  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.
• purplezooey 6y ago
  Wait I thought everyone was switching to dwm now..
• zitterbewegung 6y ago
  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
• waiseristy 6y ago
  * 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
• lioeters 6y ago
  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
• gwbas1c 6y ago
  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.
• mikekchar 6y ago
  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 ;-)
• jedberg 6y ago
  > 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.
• Ayesh 6y ago
  - 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!
• morty_s 6y ago
  - vim - grep (now using ripgrep) - code navigation - rust - functional programming (scheme, Erlang, Haskell, Elixir, etc; structure and interpretation of computer programs).
• adultSwim 6y ago
  Listening
• Curzel 6y ago
  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 6y ago
    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.
• soumyadeb 6y ago
  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.
• T3RMINATED 6y ago
  grep
• ineedasername 6y ago
  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.
• mmargerum 6y ago
  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 6y ago
    Could you give your top 5 Rich Hickey videos for begginers?
• xzlzx 6y ago
  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 6y ago
    Which one do you recommend?
• royalghost 6y ago
  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-all-instances-of-selected-region-in-sublime-text https://stackoverflow.com/questions/12162047/how-to-select-a...
• wruza 6y ago
  - 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.
• bitwize 6y ago
  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.
• 4g3ntS33 6y ago
  Node Red
• soulnothing 6y ago
  * 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.
• manicdee 6y ago
  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.
• closeparen 6y ago
  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)
• theCodeStig 6y ago
  - 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.
• xs83 6y ago
  - 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
• synthc 6y ago
  Magit, before I used Magit using git was a chore, now it is a pleasure.
• shawnsbrain66 6y ago
  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.
• PostPlummer 6y ago
  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.
• gofreddygo 6y ago
  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."
• rubyron 6y ago
  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.
• metreo 6y ago
  Linux
• bobbydreamer 6y ago
  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.
• Frank93 6y ago
  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.
• deleted 6y ago
  [deleted]
• zjy 6y ago
  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.
• anonu 6y ago
  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
• kadams54 6y ago
  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.
• thellimist 6y ago
  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.
• tarrsalah 6y ago
  Emacs, Magit.
• srachamim 6y ago
  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.
• seymores 6y ago
  Postico