What methods, practices, tools, or methodologies helped you noticeably increase your development time?
The Ruby ecosystem is also great for scripting away the most time consuming parts of free lancing. For example, I didn't like some of the existing tools for handling AWS command line deployment, so I spun up my own solutions that fit my needs well in a few hours. I've been using that solution on every project for the last 5 years. It's changed and I've updated it a bit but I'd say no more than 10 hours of total time have ever gone into it in 5 years.
I can use the same exact language and features for everything from application development to scripting. If definitely speeds me up. Ruby and Rails aren't cool. But they work well.
Even if you’re already using RAD frameworks, start building yourself a library of boilerplate and utilities on top of it that you can reuse in multiple projects.
Avoid single-page apps and JS-rendered clients until you really need them for interactivity. They basically double the work.
I would suggest fork one of the existing ones and modify it. Rolling out your own boilerplate library can be a time sucker in itself.
Life is too short to wait for nothing. Nothing is more annoying than your computer slowing down and you having to close applications to free up some RAM or some analysis you want to do on a large DB to take forever. They are distractions that are easily removed by throwing some money at it.
If you can, get a 1Gbit connection, it's life changing to have package installations and downloading DB dumps to take seconds instead of minutes (or hours).
Ideally, I think we can agree (if we don't please inform) that if we could snap our fingers and have an app that the client wanted that would be preferable to making one for, say, six months. If I had to snap twice I'd do that too. If I had to snap ten times that also wouldn't be so bad. For a week worth of snaps it would be boring but hey, six months work in a week? Why not. If we agree, then we're following the path of least resistance to our goal. We want the greatest reward for the least work. Value to cost ratio as close to infinity as we can get it.
What that means for software development is that when I hit one key, I want an app to appear. If not an app than a service. If not a service than a module. If not a module than a file. If not a file than a snippet. If not a snippet than a command. The most code, the least amount of typing (ie, work). As little guessing, wondering, searching, typing and thinking as possible. As little work as possible. Everything straightforward, familiar, routine, and simple.
For me, this becomes a process of planning, study, action, reflection, measurement. Write your expectations and designs (very high level), google around and see what you can find. Implement. Periodically reflect on your implementation and measure yourself and your work to find inefficiencies, process, and habits that can be improved. I like to use a Pomodoro to keep track of my time and how long it takes to do certain things. If something is taking time I keep a record of it and use my record as a baseline, then I experiment and see if changes I've made to my work produce better results.
Here are a few concrete things to consider:
- Take advantage of sharing (google, check product hunt, look at Awesome lists, aws, etc). Don't re-invent the wheel.
- When green-fielding, Code for as long as you can before you start testing. This is especially true if you're running your code on an emulator (like a mobile app) and it loads slowly. If you make heavy use of mutations and side effects this might be difficult, so try to make your functions stateless and self-contained. It limits the scope of your error to a smaller service area.
- If you're building an app from scratch for a client, consider learning a design took first and getting that stuff out of the way early on without having to code. Framer, invision, adobe xd, and sketch come to mind.
- Compilers are your friend. If you use a language that has a good compiler, you can catch many errors as soon as you save the file.
- If you're doing visual work, live reloading is your friend, especially for styling. If you're using component-based libraries for the web (React is great), you can get a lot done quickly with Storybook, which allows you to isolate individual components and work on them without having to interact with the whole application.
- When you create a project, rely on templates like create-react-app.
- When creating files and functions, also rely on templates and snippets.
- When editing code, personally nothing beats Vim keybindings. Great for combating repetitive strain too. I find I code slower but get the same amount of work done. It's great on the arms.
- Use an ide for autocompletion, snippets, debugging and the like (if you prefer text editors, you can usually get language servers, snippets, and debugging ui as plugins. Even for Vim or Emacs).
- use a debugger
- USE A DEBUGGER
- For backends, services and frameworks go a long way (PHP/Laravel, Python/Django, Ruby/Rails).
- Mouseless navigation with vimium is beautiful.
- if you're a Linux connoisseur, and you're really digging the mouseless thing, I recommend i3. Great, simple, tiled window manager.
2. Raspberry pi local cluster for testing deployment and updates.
3. Having multiple Routers with WIFI AP for VPN, No VPN and tor for fast anon research.
4. Password manager like Bitwarden.
5. Bash alias
6. Intellj IDEs
7. Zsh history
8. Key based password less login
9. A good mouse
10. In coffee shops, a WiFi adapter with max allowed power with 5-6dbi antenna
11. Raspberry pi running Pihole.
12. postman/insomnia
13. Apex up/lambda
12. Terraform