Comments by "xybersurfer" (@xybersurfer) on "Continuous Delivery" channel.

  1. good point. i always put those side projects on my resume
    6
  2. don't be silly. even live coding examples are biased in that it's an example that the author is comfortable showing
    5
  3.  @ThomasVWorm  no. that's too simplistic. programming languages are not neutral. some make it easier to get things wrong
    4
  4.  @henkvanboeijen7643  it was? the syntax quickly gets complicated past simple stuff. but i guess i could see how the wordiness was meant to be a low barrier
    4
  5. do you have any opinion on GraphQL, that promises to allow clients to retrieve exactly what they want? i haven't looked at it very in depth myself but it seems like a really concept although the implementation seems to fall a bit short (my first impression). i think the concept is interesting because it wants to get rid of predicting a client's most likely access patterns, like you mention here. firing something like an SQL query at a service is a scary but interesting concept of removing indirectness
    4
  6. indeed. every barrier between design/UX people and developers is a problem. i think the discussions can sometimes also help to keep each other in check
    3
  7. if it's LISP, then where are the macros?
    3
  8. you using the term "exceptional circumstances" is a red flag to me, because it's vague and an often misused term. "not as a tshirt catch all umbrella" is similarly a red flag to me, because the most work in error handling is avoided in the case you have a single place to catch all exceptions. "Receivers handle their own ish" is vague and possibly wrong, because something at a lower level doesn't know the context it is being used in and so the error should bubble up. "Callers check their results" sounds like you are suggesting passing error values that need to be checked after every call, which is error prone, instead of throwing exceptions. i agree that exceptions should indicate where they happened, and not be rethrown. i'm not trying to make hasty conclusions, but i'm just expressing my concern.
    2
  9. this resonates with me. it makes me even more interested in your new book. i'm not sure whether i should wait for some reviews
    2
  10. My feeling is that your tests are a form of declarative "programming", especially when they test the full specifications. The problem i see with the functional example is that there are lots of nested brackets when written in that style. Usually there is some kind of "|>" pipeline operator in functional languages, that passes the result from one lambda onto the next, to prevent some of this: def declarative_words(dictionary) dictionary |> filter (lambda word: 5 == len(word)) |> list |> return Now you can see the steps more clearly. You could argue that the requirement for an order makes this imperative. You could also argue that specifications require you to specify an order in some parts. But calling specifications imperative seems strange (they are declarative). The line is very blurry, but maybe it's because i'm considering some expressions as imperative as opposed to only statements
    2
  11.  @black-snow  oh ok. i was thinking there was a git command. but that makes sense
    2
  12. ​ @NicodemusT  you are talking based on too many assumptions. finding youtubers that are picking topics live, doesn't prove that they are picking topics they are uncomfortable with. even when we find a youtuber and somehow prove that they can code any topic live, it still does not prove that it is better to do things that way. one problem with this approach for me is that i don't always want to sit through all the fumbling (while i do admit it can be fun sometimes). similarly with text books it's nice to have a distilled version of all the ideas. that doesn't mean that a demonstration doesn't have it's place, but it's not necessarily better as you seem claim.
    2
  13. exactly. and it goes for all team members. nothing should be set in stone, because that's where you start to get problems
    2
  14. it really is a balancing act. i always find that the tools are what limit what can be expressed, and that over engineering usually happens when trying really hard to get around these limitations. sometimes the limitations are due to a lack knowledge, and therefore making things more complicated than necessary. and yes you always have to ask yourself, whether the added complexity is worth it, like you said. with tools i mean pretty much anything given to you, like: frameworks, protocols, IDEs, the operating system, but especially programming languages
    2
  15. because it could have been so much better at serving it's purpose, that's why
    2
  16. because you only know JavaScript and CSS? maybe you don't know JavaScript well enough to know the bad parts? JavaScript and CSS are not completely separate. you can for example change the CSS of HTML elements using JavaScript.
    2
  17. really good point about design vs. requirements. it's very recognizable, when the client is trying to be the designer. i've found that it's better to start the design from the database model, rather than what the screens should look like. although nothing is of course absolute, and there can sometimes be some useful design ideas in just picture of screens that need to be taken into account, when evaluated carefully
    2
  18. i mostly agree. but i usually consider a violation of business logic, to be worthy of throwing an exception. i say "usually", because the frameworks i've worked with have a few places where they expect Error Values (like result objects). the problem with Error Values is that you typically get the Arrow Anti-Pattern
    2
  19. agreed. especially with what he describes as them leaving a mess
    2
  20. i think it's about the movie Back to The Future, which is about time travel. pressing CTRL+Z (undo) is like traveling back in time
    2
  21. the comments here suggest otherwise
    2
  22. it also doesn't mean that it does have a place
    2
  23. ask yourself why ArithmeticException are unchecked. you should always be ready for an unexpected error
    2
  24. but that's kind of a symptom of a bad base language. it contains so much junk that people don't know which parts they should be using. i think that the "this" keyword was one of the worst inventions in the base language, that should never have existed
    1
  25. interesting. this has me curious about what Behavior Driven Development is. it's a new topic to me
    1
  26. the reliability and maintainability of code, is directly affected by the quirks of the language
    1
  27. controlling when updates happen, is the main reason why i can't stand forced windows updates
    1
  28. it sounds like they are trying to get estimates on a too detailed level. i would tell them that it's a too detailed level, and add a huge disclaimer if they force you to re-estimate. you can also explain the kinds of things that still need to be done, despite it looking finished
    1
  29. overtime should come with overpay
    1
  30. this is also what i've had in mind as a good role for Generative AI. a challenge is specifying the performance requirements especially for algorithms it comes up
    1
  31. ​ @jasonfreeman8022  i don't think things like Word's XML format is meant for hand editing. do you dare to do things merge and cherry pick? that's always the thing with these formats, even if it's text based. also while it's true that not being able to safely go back allows you to not have to commit to bad decisions, you still end up doing some code refactoring. i'm just saying that version control certainly helps, but it's not a silver bullet
    1
  32.  @black-snow  how does copying a single line from SO, delete all your work?
    1
  33.  @NicodemusT  so they are picking topics they are comfortable with, live
    1
  34. i'm a bit confused about how you tested the display. the code doesn't test what is visible. you would need to capture the screen? why did you make that decision?
    1
  35.  @ContinuousDelivery  oh i see. that seems fair. thanks
    1
  36. @alexaneals8194 good point about front-end and back-end developers working together. i suspect that this is more often the case than developers and designers working together
    1
  37. sounds very relatable. so many useless riddles that need to be solved
    1
  38. what do you mean with nodes?
    1
  39. over-specification is fine if the stakeholders are willing to deviate in case of "problems". under-specification allows developers to creatively cut down on the amount of work required, but mostly wastes a lot of time if it's bad enough. it can be a delicate balance
    1
  40. with automating acceptance tests, do you mean a high level test? otherwise i don't see how you would automate user tests. i love the shirt by the way
    1
  41. i think the language and framework you are using play a huge role too. these can force you to hurt the readability of your code and they determine which changes are practical
    1
  42. JavaScript is a huge improvement over PHP, but it's still terrible
    1
  43. what would code look like where JS was the true limiter? do you have the ability to recognize it? especially as you would probably only see things that worked out in the end
    1
  44. good points again. i've experienced the testing in production issue and the bad documentation. it's interesting that i never considered the lack of control over the configuration of such systems. i'll be checking out your new book, i like the reviews and can always use some wisdom (already ordered a copy)
    1
  45.  @simonk1844  you should use what is supported by your platform. functional programming languages typically have a compiler that forces you to do something with the return values. but most languages are imperative and have don't support this. if you use return values in those languages just because you like that style, then you will forget to check return values leading to silent errors. also partial function applications for monadic style error handling that is typical in functional programming, is not always supported, which will probably also result in the Arrow Anti-Pattern. so if you want reliable software, then the choice has typically already been made for you. i think the interesting discussion, is why checked exceptions are such a nuisance. the problem with checked exceptions is that they make the assumption that the caller always cares which specific error occurred. this is almost always a wrong assumption. not only because it assumes that the calling function is responsible for handling the error. most of the time, programs only care in it's decisions, whether the call failed or and pass on the error details to a human. it would be better if checked exception just advertise the possible exceptions and allow the caller to switch "something" on that forces them to check these for the few cases it actually matters, instead of introducing tight coupling that breaks all callers who don't even care about which specific errors can occur. technically, the fact that unchecked exceptions exist, already means that there is a hole in reliability of checked exceptions making them useless.
    1
  46.  @simonk1844  you should use what is supported by your platform. functional programming languages typically have a compiler that forces you to do something with the return values. but most languages are imperative and have don't support this. if you use return values in those languages just because you like that style, then you will forget to check return values leading to silent errors. also partial function applications for monadic style error handling that is typical in functional programming, is not always supported, which will probably also result in the Arrow Anti-Pattern. so if you want reliable software, then the choice has typically already been made for you. (editing...)
    1
  47.  @simonk1844  you should use what is supported by your platform. functional programming languages typically have a compiler that forces you to do something with the return values. but most languages are imperative and have don't support this. if you use return values in those languages just because you like that style, then you will forget to check return values leading to silent errors. also partial function applications for monadic style error handling that is typical in functional programming, is not always supported, which will probably also result in the Arrow Anti-Pattern. so if you want reliable software, then the choice has typically already been made for you. (editing...)
    1
  48.  @simonk1844  you should use what is supported by your platform. functional programming languages typically have a compiler that forces you to do something with the return values. but most languages are imperative and have don't support this. if you use return values in those languages just because you like that style, then you will forget to check return values leading to silent errors. also partial function applications for monadic style error handling that is typical in functional programming, is not always supported, which will probably also result in the Arrow Anti-Pattern. so if you want reliable software, then the choice has already been made for you typically. (editing...)
    1
  49.  @simonk1844  you should use what is supported by your platform. functional programming languages typically have a compiler that forces you to do something with the return values. but most languages are imperative and have don't support this. if you use return values in those languages just because you like that style, then you will forget to check return values leading to silent errors. also partial function applications for monadic style error handling that is typical in functional programming, is not always supported, which will probably also result in the Arrow Anti-Pattern. so if you want reliable software, then the choice has typically already been made on your behalf. (editing...)
    1
  50.  @simonk1844  you should use what is supported by your platform. functional programming languages typically have a compiler that forces you to do something with the return values. but most languages are imperative and have don't support this. if you use return values in those languages just because you like that style, then you will forget to check return values leading to silent errors. also partial function applications for monadic style error handling that is typical in functional programming, is not always supported, which will probably also result in the Arrow Anti-Pattern. so if you want reliable software, you typically don't have a choice. i think the interesting discussion, is why checked exceptions are such a nuisance. the problem with checked exceptions is that they make the assumption that the caller always cares which specific error occurred. this is almost always a wrong assumption. not only because it assumes that the calling function is responsible for handling the error. most of the time, programs only care in it's decisions, whether the call failed or and pass on the error details to a human. it would be better if checked exception just advertise the possible exceptions and allow the caller to switch "something" on that forces them to check these for the few cases it actually matters, instead of introducing tight coupling that breaks all callers who don't even care about which specific errors can occur. technically, the fact that unchecked exceptions exist, already means that there is a hole in reliability of checked exceptions making them useless.
    1
  51. don't unspecified and incorrect specifications, both allow improper outcomes that are undetected?
    1
  52. sequentially making asynchronous calls, could still have the advantage being able to do other things while waiting. but i recognize not being able to take full advantage of asynchronous calls, because of design decision out of my control
    1
  53. great points. i can really relate to not finding the domain as interesting, as the process of developing software
    1
  54. ​ @acasualviewer5861  having always to convert the abstraction level introduces more churn
    1
  55.  @acasualviewer5861  yes NullPointerException is a bug and so is ArithmeticExceptions. but so what if it's a bug? am i supposed to feel guilty now when we know that everything can contain bugs? it's a meaningless distinction. yes in some special cases it's nice to know beforehand what Exceptions can take place, but typically all Exceptions from the same call, are handled the same way. with the simple conclusion, being that the call failed. from a language design perspective, you can't add new checked exceptions to dependencies, without making the code incompatible. the problem is that advertising the possible Exceptions is synonymous to handling them immediately. 2 completely separate concepts. a NullPointerException is actually a language design mistake. it's a popular perversion of the Optional type. it should be up to the developer to choose whether a datatype can be null (Optional) regardless of what the datatype is. again 2 completely separate concepts.
    1
  56. ​ @acasualviewer5861  so what if a ArithmeticExceptions is a bug in the code? checked exceptions can also be the result of a bug. the question is not whether there is a difference between exceptions. most code out there doesn't care about what caused the exception, and just cares about whether or not there was an exception. that's why it's a problem that checked exceptions assume that caller cares. the caller is forced to write boiler plate code to handle it. it's a bad design. it's very naive
    1
  57. ​ @acasualviewer5861  as i said, forcing the caller to declare or handle all possible exceptions is a waste of time for the caller. you didn't understand my reply
    1
  58.  @RolfMuellerAu  i'm jealous
    1
  59. AI generating different things to the same question is due to a setting usually called "Temperature", that makes the output less predictable the higher it is. it was probably created as a way to mask the limitations (i also hate this because i too value reproducibility). if i'm not mistaking, generative AI can be fed its previous output to improve upon. i think the focus should be more on the human making the incremental changes to the specifications. the AI working incrementally is more of a detail, that may or may not be necessary to implement the specifications
    1