• 0 Posts
  • 58 Comments
Joined 2 years ago
cake
Cake day: October 23rd, 2023

help-circle

  • I see. That sounds very over-zealous to me, yes. The delay in moving off is so small that it doesn’t really have a safety impact (and the idea that a delay in moving off is a safety issue is way overblown in general, because the occasions when it comes up are so rare compared to the occasions when adequate braking comes up.).

    The beefier motors do cost more, and I haven’t seen a cost comparison. I would imagine they don’t cost much more though, and soon pay for themselves if you’re driving in the city. And they won’t overall increase fuel consumption - that much is clear from measurements. A random reddit post claimed that the break-even point in stop-start is a mere 7 seconds, which is basically every red light. Idk if that’s reliable but it gives you something to consider.


  • Stop signs are not a big part of driving in some countries. I obviously don’t know about everywhere, but in other countries I’m familiar with (Europe), most USA “stop” junctions are give way/priority/yield junctions where you don’t have to come to a complete stop, so stop-start would have no impact.

    In the UK, you only get Stop signs on junctions where your view is so extremely limited that anything less than a stop or absolute dead crawl would just always be dangerous. They’re very rare. In comparison, Yield signs in the USA are comparitively rare (in my experience) and most junctions where you most yield priority are governed by Stop signs.


  • Engines with start-stop have beefier starter motors. Electric motors can be sized for basically any task - the motors in my EV are not going to wear out and their duty cycle is crazy compared to a starter motor! So it’s just a matter of cost and size.

    Sounds insane to require drivers to disable start-stop to pass a test - where’s that? You mention stop signs so that sounds like the US. I’m afraid I don’t really trust US driving tests to accomplish anything sensible…


  • Typically it experiences most wear at start because the oil isn’t up to temperature. When stopped at a red light, oil is still coating all the components, so while the pressure may be low, it will only be a momentary increase in wear. 7 seconds is very little compared to the time it takes the engine to get up to temperature on a cold morning, which is wear the majority of wear will still come from.

    These systems have been in common use for like 15 years or something, and first became commercially available over 25 years ago. We’d have actual hard evidence if it were causing excess wear.















  • Either way gets me to a passing test, but I prefer the latter because it enables me to write another failing test.

    But you could just write that failing test up front. TDD encourages you to pretend to know less than you do (you know that testing evenness requires more than one test, and you know the implementation requires more than some if-statements), but no-one has ever made a convincing argument to me that you get anything out of this pretence.

    Tests should make changing your system easier and safer, if they don’t it is typically a sign things are being tested at the wrong level

    TDD is about writing (a lot of) unit tests, which are at a low-level. Because they are a low-level design-tool, they test the low-level design. Any non-trivial change affects the low-level design of a component, because changes tend to affect code at a certain level and most of those below it to some degree.


  • When faced with a failing test, you make it pass as simply as possible, and then you summon all your computer science / programming experience to refactor the code into something more elegant and maintainable.

    Why bother making it pass “as simply as possible” instead of summoning all that experience to write something that don’t know is stupid?

    TDD doesn’t promise to drive the final implementation at the unit level

    What exactly does it drive, then? Apart from writing more test code than application code, with attendant burdens when refactoring or making other changes.