
Ask HN: Full stack devs, what helped you noticeably reduce development time? - Babiker
As a new freelancer, I feel that it takes me a long time push projects that aren&#x27;t really that big.<p>What methods, practices, tools, or methodologies helped you noticeably increase your development time?
======
trcollinson
As silly as if may sound, the thing that helped me the most is Ruby and Rails.
Rails was designed with the idea that small groups of people could make robust
applications quickly. So as a full stack developer, it works out very well.
Some would say it accomplishes this at the expense of speed of the
application. I write mostly line of business applications with no more than
10s of thousands of concurrent users and no more than 100s of thousands of
users total. I would say my applications perform as well or better than any of
their competitors that were built on other frameworks but in a faction of the
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.

------
cimmanom
Use a batteries-included RAD framework (like Rails or Django).

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.

~~~
wreath
> 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.

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.

~~~
lastofus
Learning and customizing someone else's boilerplate can be just as time
consuming, though you will probably learn a thing or two in the process.

------
photonios
Get some beefy hardware and a high speed internet connection. Don't cheap out.

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).

------
drbojingle
Most people are adding specifics, I want to start in the abstract and move to
concrete, mainly to address principles that influence my concrete choices.
Bare with me for a paragraph or two.

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.

------
Antoninus
Vim.

------
clanrebornwow
1\. 1Gbps internet

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

