9 ms·

Ask HN: What technologies greatly improve the efficiency of development?

• Tommabeeng 5y ago
  Decoupling
  • GoldenMonkey 5y ago
    Agreed. and unit tests can help force decoupling.
• ignoramous 5y ago
  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).
  • ajdoingnothing 5y ago
    Fortunately, there is a newer edition ;) The Pragmatic Programmer, 20th Anniversary Edition: https://www.amazon.com/Pragmatic-Programmer-journey-mastery-Anniversary/dp/0135957052 https://www.amazon.com/Pragmatic-Programmer-journey-mastery-... +1 on CI & automated tests BTW.
• troutwine 5y ago
  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.
• joezydeco 5y ago
  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.
  • d4rkp4ttern 5y ago
    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 https://github.com/arogozhnikov/einops
  • swagasaurus-rex 5y ago
    Its also easier to search through a codebase for unique and specific variable names.
    • sam_bristow 5y ago
      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.
• kitd 5y ago
  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.
• juancampa 5y ago
  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
  • a-dub 5y ago
    ding!
• cpeterso 5y ago
  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/ https://pernos.co/
  • cpeterso 5y ago
    oops! s/decision/debugging/
• mooreds 5y ago
  > [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.
• d4rkp4ttern 5y ago
  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.
  • rochak 5y ago
    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.
• SmileyJames 5y ago
  > 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
  • nerj 5y ago
    Are you saying to pair program instead of using PRs?
• mbrodersen 5y ago
  Automatic system level tests.
• nickd2001 5y ago
  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
• codeptualize 5y ago
  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.
  • joshxyz 5y ago
    Good lord, ESLint is god-sent. Type checks also catches a lot of run-time errors.
  • aitoehigie 5y ago
    This is one of the reasons why any project I work with, I always include pre-commit (pre-commit.com).
  • oweiler 5y ago
    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.
    • mooreds 5y ago
      > 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.
• aib 5y ago
  Source control
  • noud 5y ago
    Second this!
• Qem 5y ago
  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/ https://mooc.pharo.org/
  • metroholografix 5y ago
    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.
    • scroot 5y ago
      > 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.
• bauerd 5y ago
  Type systems
• Gravyness 5y ago
  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.
• abstract_put 5y ago
  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.
• ultra_nick 5y ago
  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.
• egman_ekki 5y ago
  - 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
  • alexchamberlain 5y ago
    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?
    • egman_ekki 5y ago
      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.
• Ozzie_osman 5y ago
  A good IDE set up, with automatic code formatting, real-time linting, autocomplete/autoimport, and something like Github copilot.
• s5300 5y ago
  Coax all team members into getting proper sleep, exercise, nutrition, & potentially amphetamines.
  • qualudeheart 5y ago
    Better living through chemistry.
• matthewmacleod 5y ago
  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.
• eliseumds 5y ago
  Github Copilot and Actions.
  • Kiro 5y ago
    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.
    • aitoehigie 5y ago
      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.
• tiffanyh 5y ago
  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.
  • ksec 5y ago
    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.
    • tiffanyh 5y ago
      Do you dislike C syntax? Because PHP is basically C with dollar sign $variables.
      • ksec 5y ago
        >Do you dislike C syntax? Kinds of, yes. And the dollar sign is especially programatic for me as I read lots of financial reports and statements. Part of the reason I dont like Perl as well.
  • mxuribe 5y ago
    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.
    • emteycz 5y ago
      I always thought the reason was that nearly every webhosting offers it, even though it has serious warts.
• softwaredoug 5y ago
  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.
  • eurasiantiger 5y ago
    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.
    • cercatrova 5y ago
      I've been using it and it's exactly as you say. It's honestly incredible.
• traverseda 5y ago
  Django's admin system.
  • samwillis 5y ago
    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.
• deleted 5y ago
  [deleted]
• sokoloff 5y ago
  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.
• awestbro 5y ago
  [dead]
• jjice 5y ago
  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.
• djohnston 5y ago
  Fzf for command line history fuzzy matching.
• labarilem 5y ago
  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.
• LandR 5y ago
  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.
• adrianmsmith 5y ago
  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.
  • loloquwowndueo 5y ago
    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.
• 4maz1n 5y ago
  Ruby
• sirwhinesalot 5y ago
  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.
• indymike 5y ago
  1. Continuous delivery. 2. Git, mercurial, bazaar. Dvcs. 3. Code formatters, static analysis 4. Cloud services. No talking to sales to get another server.
• mark_l_watson 5y ago
  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.
• svilen_dobrev 5y ago
  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" ..
• rozenmd 5y ago
  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
• menotyou 5y ago
  Using either functional or imperative languages.
• lfpeb8b45ez 5y ago
  A whiteboard in a shared space. Still haven’t found anything that can replicate the impact in a remote setting.
  • Step888 5y ago
    This VR blackboard on the Oculus Quest looks interesting. https://www.youtube.com/watch?v=Aiw3m8EK0rs&t=2s 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)
  • anotherhue 5y ago
    Checkout https://excalidraw.com/ https://excalidraw.com/
  • marcind 5y ago
    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 https://sharetheboard.com