What technologies greatly improve the efficiency of development?

I think automatic code formatters have huge impact.

Not just to save time on manually formatting code, they also flag syntax errors; if it doesn’t format on save you know something is wrong.

In team context they take away all bike shedding about formatting. Code reviews can focus more on stuff that matters, not just silly formatting tweaks.

To me a good formatter is as essential as autocomplete.

Anything that reduces the code -> build -> test cycle:

Automatic test runners, Hot-reloading, Incremental compilers, Static typing, Build farms (when working with massive code bases), Compiler caching: ccache, sccache

PHP

For all the hate PHP gets, a massive positive of it is entire classes of development friction that just doesn’t exist for it.

COMPILE: Slow compile times, nope - it’s interrupted & you can run the code instantly.

DEVELOPMENT: Confusing and complex development tooling or middleware, nope - just SFTP a single file to your webroot.

So the language / environment you pick to develop in can has massive impact on productivity.

There are so many, but there are three in particular that in my experience are most important and weirdly lacking in a number of organisations:

- Type checking (and particularly modern type systems) can remove entire classes of error – often reducing the long-term maintenance cost of code substantially at the cost of (sometimes) slowing down initial development.

- Automatic and enforced code formatting and linting eliminates almost all bikeshedding and feedback loops around formatting and code style, and is an observable efficiency improvement.

- Continuous integration without a doubt. Build every source control push or PR into an artefact that's ready to deploy, along with validation and automated testing. Basically remove all manual processes from every system to the fullest extent possible.

Also, can't stress enough – fix anything that irritates you as soon as you can. Is your IDE failing to resolve some types properly? Fix it. Annoyingly long debug build times? Flaky tests? Stupid manual environment setup scripts? Fix them – you almost always fail to realise how much stress these things are causing you until they are gone.

If delivering quality software is of essence, then investing in CI and automated tests will have an outsized impact as the project evolves.

And read The Pragmatic Programmer (which may be in need of a newer edition).

- Automated testing running on each PR

- Having a dedicated Quality team

- Ensuring everyone is on the same page, from the lowest level (coding standards) to mid level (discussing tasks before implementing them) to meta level (principles for development, building culture)

- Rewarding bold moves and experiments, giving people freedom to be creative

- Leveraging the wisdom of the Open Source community

Good tests. We don't have fantastic tests at my current job, but we're working on it.

Noticing something broke in a place you didn't expect before it appears in production ends up being a massive time saver and anxiety reducer.

Good tests seem tricky, since you want a combination of flexibility and rigidity, which can be a tricky balancer, but well worth it if done right.

After using copilot - that’s not it (yet).

The most useful completions would also be done by an IDE. Especially in statically typed languages.

The borderline useful of the completions, you spend a lot of energy scanning a seemingly ingenious solution for bugs. And usually there’s enough one or two deceptively silly bugs that I wish I had just written the code.

The rest are silly and entertaining completions. Honestly the LOLz from these completions are the reason I still use copilot.

Great suggestions here. I would like to add another:

Language choice. I happen to fancy Common Lisp but any language with a good REPL experience works. I like to play with small bits of code interactively in a REPL and when things works copy to a source file. Tools like Slime also help.

Python with the old Emacs Python bindings works well because you can load an entire source file and then re-evaluate individual function definitions as you modify them. This may seem similar to what you can do in a Jupiter notebook but I find Emacs + Python bindings better.

Haskell also lends itself to REPL driven development.

> [what] improved the development efficiency of your team?

* I think that the daily standup is great! Preferably virtual/slack, if you are consistent it will help remove roadblocks and people chasing rabbits down holes (that is, getting stumped and not making progress).

* Clear quarterly goals and monthly meetings with external stakeholders have been helpful to me in the past. This was for smaller teams, but it's fantastic to make sure that you aren't efficiently developing the wrong software.

* CI and automated tests were truly a lifesaver when I built a startup codebase from scratch and they're helpful now (at a different company) in preventing regressions. It's painful to introduce TDD or automated tests if you don't have them, but I promise you, when that regression is caught in CI 6 months from now, you'll be happy you paid the price.

Time-travel decision like rr and Pernosco. I’ve heard firsthand stories from developers that found and fixed rare race condition bugs in minutes instead of hours or days. https://pernos.co/

I would say it's not so much about improving the efficiency of the team, but rather removing things that reduce the efficiency of the team, of which there are many.

For me it's Scrum. Every two weeks we have a full-day meeting with the entire team. In addition, every Thursday and Friday we have a meeting mid-morning of "analysis" (whole team) which means I can't get anything significant done beforehand, nor afterwards in the morning. That only leaves the afternoon, and I'm sort of a morning person, so most Thurs/Fri afternoons I don't get anything done either. I do want to get a lot done, but the company gets in my way, so what am I to do, I have to accept it.

Debugging tools, especially conditional breakpoints. I’ve come across far too many people who say “yeah I use PyCharm” (for Python) but when I ask them if they’ve used the debugger, they say they don’t know how to use that. Investing time in learning to use the debugger and especially how to insert conditional breakpoints can be a lifesaver.

Encouraging people -- and myself! -- to take walks and ponder, rest and get a little distance from the work. There's nothing quite so handy for understanding something as letting your mind work on it in the background while you take the air.

Long, self-documenting variable names.

Because someone else will eventually have to debug or rework your code. And that might even be you, six months from now after you've forgotten everything.

It's relatively cheap and cross platform compatible.

REPL* and paredit for Lisp/clojure code.

It's hard to describe in a way that sounds compelling, but once you've experienced it, it's profoundly faster and (therefore?) more joyous than any other dev experience I've had.

* Cider / SLIME for me.

While not quite ready for public consumption, I'm working on a project that allows front end developers to build websites visually with templates and utility classes called ProductDiv https://github.com/awestbro/productdiv. As a web developer of ~10 years I wanted a tool that could match the productivity of something like Elementor while producing clean code. There are a few other tools out there, but I wanted something that:

- Focused on utility classes and clean code

- Is extensible with your own templates

- Local config, not service based so everything is version controlled and always available for all members of your team

- Framework agnostic, but configurable for utility classes (currently bootstrap) with any framework that produces HTML

Visually building and sites is a game changer for me as I can save a ton of time dragging templates onto pages while making small adjustments with the utility class editor. To give it a try, you can download the repo, npm i, and npm run dev. I'd love some feedback on UX!

A good IDE set up, with automatic code formatting, real-time linting, autocomplete/autoimport, and something like Github copilot.

I'm not sure if it's a method, but understanding what bottlenecks are involved in your development cycle is key to anything involving efficiency. Just like early optimization of software it's very easy to add a step on a complicated system only to find out it wasn't very effective because there wasn't a problem there to be solved.

You need a way to evaluate efficiency and trends of your development cycle. Are you creating more tasks than are done? Are there too many bugs being created? Is the layout design often late and blocking your developers? Ask yourself how would you know about these things and if you don't have an answer or it takes a while to get the answer then that's where you should focus your improvements: optimizing your understanding of what is going on your value stream.

For me, a simple build tool/process that can be run locally, and also easily replicated in a CI system (that then gets run on each PR). Note this might mean running it as a docker container.

I believe the quality of the build process greatly affects the quality of the code it produces.

Django's admin system.

Automated tests that reject code if it breaks someone else's code.

I had to fix the same issues 3 times last year. We could've finished MONTHS earlier.

A whiteboard in a shared space. Still haven’t found anything that can replicate the impact in a remote setting.

Type systems

> greatly improve the development efficiency of your team?

Embrace using open source not reinventing the wheel, hopefully you are already standing on the shoulders of giants

Practise extreme programming. Test driven. Pairing. Trunk based development. Stop using PRs... that's a controversial one - pair instead

Continuously integrate and deploy.

Now optimise that loop. How long does it take a pair to get a commit on mainline. How long does it take for that commit to be live. If the commit had a bug how long does it take to revert and have the fix go live.

Write tests first. TDD. Otherwise all of the above is for nothing and you'll have very quickly developed a big pile of something that doesn't do what you want it to do

OpenAPI: while it's got tons of warts and is mostly useful for deterministic REST-ish looking APIs, it's the best think I've found so far to specify APIs. If the APIs are well expressed and maintained there tend to be a lot of positive side effects.

Other people have already gave many examples, but they can all be summarised as "shorten the feedback loop".

CI/CD shortens how long it takes to see your code running in a production-like environment.

A good type system and a good test suite help catch bugs before the program is actually run.

Short compile times (or an interpreter), hot code reloading, a good debugger, all help to see the impact of your changes faster. Even autocompletion or an efficient editor like Vim relate to getting your code done and running faster.

It all comes down to fast feedback. Reducing friction is also nice, e.g. PHP is really easy to get started, but not as important as the fast feedback IMO.

It takes some time to get used to, but systems that support image-based development, in the tradition of the Smalltalks and some Lisps, can boost programming productivity a lot, by allowing very tight feedback loops. Combined with a good debugger it makes much easier to diagnose and recover from problems, and iterate over your design quickly. To experience the state of the art on this front, I recommend Pharo. There's even a MOOC at https://mooc.pharo.org/

As a frontend web team:

TypeScript

Next.js

Investing deeply into making the build run as fast as possible

Preview deployments per branch (or preview releases of binaries for CLIs)

Integration tests that actually test how users use the product, rather than implementation details

Source control

Maybe "stating the bloomin' obvious", but docker (including docker-compose). Using containers speeds up dev massively, keeps people's envs similar, don't need to install a ton of stuff on your machine. Local behaves similar to CI which behaves similar to prod, etc

Github Copilot and Actions.

1. Continuous delivery.

2. Git, mercurial, bazaar. Dvcs.

3. Code formatters, static analysis

4. Cloud services. No talking to sales to get another server.

Besides the techs mentioned in this thread, understanding what are the minimum features to build and understanding the people working in my team. What drives them, what they like, etc.

Using either functional or imperative languages.

Repl integrated into your IDE.

When you can write code, send it to a repl from your IDE and see the results inline with the code is a game changer.

Fzf for command line history fuzzy matching.

Anything that eliminates (the need for) errors of some sorts.

e.g. somelist.map( function whatever) dying when somelist is undefined/null, vs smartermap( somelist, function whatever ) that returns empty list if somelist isn't there

or easy autocomplete of names of things

etc.

but.. the problem is, one has to be somewhat "enlightened" (or burned) to use the above in a disciplined way, instead of the seemingly easier "let me type/invent it" ..

Coax all team members into getting proper sleep, exercise, nutrition, & potentially amphetamines.

Decoupling

Automatic system level tests.

Ruby