Ask HN: What technologies greatly improve the efficiency of development?
What are the technologies or methods you've used that greatly improve the development efficiency of your team?
86 comments
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.
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.
Absolutely. Never thought they would make such a difference until I got introduced to them when contributing to SDKMAN!.
Never had a conversation about formatting afterwards.
Never had a conversation about formatting afterwards.
> Never had a conversation about formatting afterwards.
This would be worth it even if they never caught anything else or improved the quality of the code.
To be able to make a decision once as a team and have it be a non-argument going forward: such a gift.
This would be worth it even if they never caught anything else or improved the quality of the code.
To be able to make a decision once as a team and have it be a non-argument going forward: such a gift.
This is one of the reasons why any project I work with, I always include pre-commit (pre-commit.com).
Good lord, ESLint is god-sent.
Type checks also catches a lot of run-time errors.
Type checks also catches a lot of run-time errors.
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.
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.
100% THIS! There is a reason so many products and platforms - like WordPress, which powers so many blogs on the internet - were built leveraging PHP: productivity/getting stuff done! I would add that i'm not only implying that conventional developers gain productivity...but that also that PHP empowered - yes empowered - folks who may not be "real" developers, and gave them a tool/platform to participate on the production (not only consumer) side of the greater web.
There’s also a reason a ton of those applications built on php are terrible to use and get crushed under their own weight.
I do not disagree. In fact, going outside the context of tech, sometimes democratizing inventions for the lay people is great in one area, and terrible in other perspectives. One example could be the invention of the automobile which - at least in the U.S. - empowered so many people (and commerce), but it also enabled folks to do very foolish things...to the detriment of so many, many auto-related deaths every year. So, back to technology...yes, i like me some PHP, but it is not lost on me that in the hands of the less qualified (or maybe folks who know, but simply do not care), there could be significant (and widespread) downsides. ;-)
I always thought the reason was that nearly every webhosting offers it, even though it has serious warts.
Oh yeah, i agree that making PHP or other platforms more widely available helps them get more adopted. But i would have to guess that web hosting providers either were responding to customers requests to run PHP (because said customers felt they could do more), or these providers believed that php was good enough to offer to their customers because it empowered their customers but was not too much of headache to support. I say "not too much" because as noted, php has its warts. But even still if i put my business hat on, i would guess that a business would not purposefully make a platform available that is so bad which would create more work - hence tech support - that it would lessen or do away with any profit margin. In other words, if php were really that bad, web host companies - especially the low cost ones - would definitely not provide such a service because the constant tech support work would kill their profit margins...Full disclosure: i have never been a web host provider company (other than, small amounts of work in setting up web environments for my consulting clients)...so only someone in that industry could confirm/deny my theory.
As a former small-time webhoster, I ran PHP because it was the easiest to run, but that doesn't mean it was the best app platform or the easiest to develop with. Making Ruby or Python or Java hosting was out of reach back then (without Docker and other niceties of today).
I still cant get over its syntax.
Otherwise I agree with all your point. It basically kept things simple while every other web development language increase their complexity by 10 to 100x.
Otherwise I agree with all your point. It basically kept things simple while every other web development language increase their complexity by 10 to 100x.
Isn't it the same for Python?
In the sense that subsequent requests will see the changed code, yes (unless byte code cache is involved).
OP is likely referring to the mod_php convention of directly executing PHP scripts by filename/URL while Python/WSGI needs a single entry point. Your directory structure becomes your routing logic.
OP is likely referring to the mod_php convention of directly executing PHP scripts by filename/URL while Python/WSGI needs a single entry point. Your directory structure becomes your routing logic.
I use Python, but miss being able to just a .php file in a dir and have it work.
Now to make some small site, I instead end up setting up some WSGI server and doing nginx config to get it visible, upstart config to make it start at boot, and then invariably forget how it’s set up after a few months pass.
Now to make some small site, I instead end up setting up some WSGI server and doing nginx config to get it visible, upstart config to make it start at boot, and then invariably forget how it’s set up after a few months pass.
Deploying changes to a server with python tends to be more involved than just plonking a file via ftp. Even best-case, you usually have to restart a process or something (gunicorn).
nope
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.
- 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).
And read The Pragmatic Programmer (which may be in need of a newer edition).
Fortunately, there is a newer edition ;) The Pragmatic Programmer, 20th Anniversary Edition:
https://www.amazon.com/Pragmatic-Programmer-journey-mastery-...
+1 on CI & automated tests BTW.
+1 on CI & automated tests BTW.
- 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
- 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
The 2nd and 3rd points seem somewhat at odds? How do you balance team discussion with encouraging individuals to experiment and push the boat forward?
The important part for me is to make sure everyone understands _what_ needs to get done, not necessarily prescribe _how_ to do it.
But I agree it can be fuzzy. Generally I want folks to be aligned and super clear on what we're trying to do, because if everyone understands it differently, we're all pulling in different directions.
But I agree it can be fuzzy. Generally I want folks to be aligned and super clear on what we're trying to do, because if everyone understands it differently, we're all pulling in different directions.
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.
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.
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.
I would disagree. Just like an airplane copilot, GitHub Copilot really shines in rote work: when it can correctly infer what you are about to do, it can and will assist you correctly. It’s not able to make big decisions, but in a pinch, it might be able to give hints.
In short: Write your class methods or functions headers-first and then start working on the bodies. Add step-by-step comments to a body before starting to add code. These are, of course, good habits to foster even without Copilot.
Copilot will pick up what you do in the first method/function/whatever structure and suggest adapted completions for the rest.
In general, when there are multiple similar things to write, name your cases, then write one of them in detail, move to the next empty one and watch magic happen.
If used right, Copilot can give developers a significant velocity boost, especially in greenfield projects where there is lots and lots of boilerplate to write.
It is still a ”copilot” though so keep an eye on it, lots of ”wtf is that guy doing” moments ahead for sure.
In short: Write your class methods or functions headers-first and then start working on the bodies. Add step-by-step comments to a body before starting to add code. These are, of course, good habits to foster even without Copilot.
Copilot will pick up what you do in the first method/function/whatever structure and suggest adapted completions for the rest.
In general, when there are multiple similar things to write, name your cases, then write one of them in detail, move to the next empty one and watch magic happen.
If used right, Copilot can give developers a significant velocity boost, especially in greenfield projects where there is lots and lots of boilerplate to write.
It is still a ”copilot” though so keep an eye on it, lots of ”wtf is that guy doing” moments ahead for sure.
I've been using it and it's exactly as you say. It's honestly incredible.
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.
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.
* 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/
oops! s/decision/debugging/
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.
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.
That’s not strictly speaking scrum’s fault. The analysis meetings are not part of it, and the full-day biweekly meeting seems excessive - demo and planning when closing a sprint should be at most half a day. It sounds like the team is too big if you’re using so much time in meetings - takes a long time for everyone to do their demos and then still longer to plan the next sprint (too-big team = “too much capacity” - so planning all the work takes too long). Maybe split into two teams and have them pick work from the backlog independently, or have two backlogs depending on each sub team’s strengths.
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.
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.
I use pdb to debug via the CLI and don’t face any problems. I default to the CLI for debugging and try to look for GUI alternatives only after nothing works.
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.
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.
A version of this is extremely useful in Deep Learning code, where a lot of time is spent trying to guess the shape and dims of tensor variables. To help with this I often name variables like inputs_b_t_f where b = batches, t = time steps, f = features.
This combined with something like einops [1] ( intuitive reshaping library) can be a huge time saver.
[1] https://github.com/arogozhnikov/einops
[1] https://github.com/arogozhnikov/einops
Its also easier to search through a codebase for unique and specific variable names.
The length of a variable name so old be proportionate to the scope. Global scope? long descriptive name. Loop variable? 'i' or 'j' is fine.
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.
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.
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.
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.
I believe the quality of the build process greatly affects the quality of the code it produces.
Django's admin system.
I like to think of the Django Admin framework as a developer superpower. I have built whole apps just with it, no need to build your own views. Perfect for internal tools.
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.
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.
This VR blackboard on the Oculus Quest looks interesting.
https://www.youtube.com/watch?v=Aiw3m8EK0rs&t=2s
(I don't have a Quest myself, so I actually don't know if I would like working with it)
https://www.youtube.com/watch?v=Aiw3m8EK0rs&t=2s
(I don't have a Quest myself, so I actually don't know if I would like working with it)
our humble proposition is to not replicate the whiteboard but teach it digital tricks like enhanced legibility, auto-save, digitization (now: save as vector; later: transcribe). in other words: whiteboard in a remote/hybrid setting.
tear it to shreds, please: https://sharetheboard.com
tear it to shreds, please: https://sharetheboard.com
Checkout https://excalidraw.com/
Type systems
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.
> 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
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
Are you saying to pair program instead of using PRs?
[deleted]
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.
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/
Pharo is more of a research experiment than anything practical than can be used to engineer complex systems, I know I tried. It comes with many flaws, first and foremost being a lack of vision (often seen in academia) that significantly holds back its potential. When it comes to Smalltalk, I find Squeak to be a far more grounded and coherent experience.
As far as state of the art in image-based development goes, that is without a doubt, still Symbolics Genera. It's depressing to realize that after all these decades, we still haven't reached this pinnacle.
Emacs (with Emacs Lisp or Common Lisp) comes the closest but is still a long way off.
As far as state of the art in image-based development goes, that is without a doubt, still Symbolics Genera. It's depressing to realize that after all these decades, we still haven't reached this pinnacle.
Emacs (with Emacs Lisp or Common Lisp) comes the closest but is still a long way off.
> Pharo is more of a research experiment than anything practical than can be used to engineer complex systems, I know I tried. It comes with many flaws, first and foremost being a lack of vision (often seen in academia) that significantly holds back its potential. When it comes to Smalltalk, I find Squeak to be a far more grounded and coherent experience.
After spending a lot of time working in both systems, I unfortunately have to agree with this. However, the GToolkit folks (built atop Pharo) do have a pretty coherent vision and their systems shows it.
The biggest problem with Squeak, to my mind, is that not enough people are working on it. They are simply shorthanded. Even now there is a VM optimization ready to go that would improve performance 3x (SISTA), but it just needs a couple of months' work from what I understand. Vector graphics is another area where there could be worthwhile improvements. Juan Vuletich seems to be making the most headway there all on his lonesome, and while he's made a VM plugin, his work is really only for Cuis Smalltalk and not Squeak.
Still, I've tried to push more and more of my routine work into these environments because I want my computer to be more like them and less like a Unix-with-lipstick.
After spending a lot of time working in both systems, I unfortunately have to agree with this. However, the GToolkit folks (built atop Pharo) do have a pretty coherent vision and their systems shows it.
The biggest problem with Squeak, to my mind, is that not enough people are working on it. They are simply shorthanded. Even now there is a VM optimization ready to go that would improve performance 3x (SISTA), but it just needs a couple of months' work from what I understand. Vector graphics is another area where there could be worthwhile improvements. Juan Vuletich seems to be making the most headway there all on his lonesome, and while he's made a VM plugin, his work is really only for Cuis Smalltalk and not Squeak.
Still, I've tried to push more and more of my routine work into these environments because I want my computer to be more like them and less like a Unix-with-lipstick.
see also https://interlisp.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
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
Github Copilot and Actions.
Why would anyone downvote this? A good answer to this question in my opinion. Copilot has had a great impact on my efficiency, often for things I didn't even realize were time sinks.
Co-pilot is useful for mainstream languages/frameworks like PHP/Laravel, Python/Django but becomes less and less useful or effectively suggestive with less mainstream ones like Elixir/Phoenix.
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
1. Continuous delivery.
2. Git, mercurial, bazaar. Dvcs.
3. Code formatters, static analysis
4. Cloud services. No talking to sales to get another server.
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.
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" ..
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" ..
Automatic system level tests.
Ruby
Coax all team members into getting proper sleep, exercise, nutrition, & potentially amphetamines.
Better living through chemistry.