Comments by "Lawrence D’Oliveiro" (@lawrencedoliveiro9104) on "ArjanCodes" channel.

  1. Let’s compare actual code, then. Here’s the level-break example I posted in another comment: out․write("<TABLE>\n") out․write("<TR><TH>Planet<∕TH><TH>Moon<∕TH><∕TR>\n") items_iter = db_iter \ ( db, "select planets․name, moons․name" " from planets left join moons on planets․id = moons․parent" " order by planets․name, moons․name" ) cur_planet = None while True ∶ item = next(items_iter, None)
    1
  2. if item == None or cur_planet != None and item[0] != cur_planet ∶ if cur_planet != None ∶ out․write \ ( "<TR><TD><I>Count∶<∕I><∕TD><TD>%d<∕TD><∕TR>\n" % count ) cur_planet = None ♯end if if item == None ∶ break ♯end if
    1
  3. if item == None or cur_planet != None and item[0] != cur_planet ∶ if cur_planet != None ∶ out․write \ ( "<TR><TD><I>Count∶<∕I><∕TD><TD>%d<∕TD><∕TR>\n" % count
    1
  4. ) cur_planet = None ♯end if if item == None ∶ break ♯end if
    1
  5. out․write("<TR><TD>") if cur_planet == None ∶ ♯ first moon for next planet cur_planet = item[0] count = 0 out․write("<B>" + html․escape(item[0]) + "<∕B>") else ∶ ♯ second or subsequent moon, don’t repeat planet name out․write(" ") ♯end if
    1
  6. out․write("<∕TD><TD>") if item[1] != None ∶ ♯ there is a moon out․write(html․escape(item[1])) count += 1 else ∶ ♯ that’s no moon out․write("<I>(none)<∕I>") ♯end if out․write("<∕TD><∕TR>\n") ♯end while out․write("<∕TABLE>\n") Show us how an ORM will make that simpler.
    1
  7.  @Gnaritas42  Show your output.
    1
  8. Code taken from here: aHR0cHM6Ly9naXRodWIuY29tL2xkby9weXRob25fdG9waWNzX25vdGVib29rcy9ibG9iL21hc3Rlci9EYXRhYmFzZXMlMkMlMjBJdGVyYXRvcnMlMjAlMjYlMjBMb29waW5nLmlweW5i
    1
  9. I would assume “whatever is currently supported”. At the moment this would be 3.7 or later.
    1
  10.  @tmseth1  Such as?
    1
  11.  @_DRMR_  I’m sure he has, but most of us like to, indeed have to, deploy on stable platforms.
    1
  12. 4:28 Also on inheritance, which you didn’t actually bother with here. Python’s duck typing to the fore!
    1
  13. So you end up predefining your queries statically in the ORM, rather than being able to construct them dynamically at run-time. Not sure that’s an advantage.
    1
  14. I do hand-coded database schemas and queries. And I often make changes to them, with the need for corresponding changes to the code. “Missed issues” will manifest themselves with SQL errors, so they won’t stay “missed”.
    1
  15.  @ipadista  Same reasoning applies to ORMs.
    1
  16.  @ipadista  I’ve never used code completion. I learned how to touch-type long before I ever got my hands on a computer. Have a look at that level-break example I posted in another comment, and see how your ORM would deal with that.
    1
  17. Cursor creation and extraction of results is such a common pattern that I like to wrap it up in a generator function, e.g. def db_iter(conn, cmd, values = None, mapfn = lambda x : x) : for item in conn.cursor().execute(cmd, values) : yield mapfn(item) ♯end for ♯end db_iter What is the point of the mapfn arg? When returning a given list of field_names, you can turn the result into a dict with something as simple as mapfn = lambda row : dict(zip(field_names, row))
    1
  18.  @MessLeadingProgramming  If your system maintains an up-to-date copy of the Olson database, then I guess that counts as “doing timezones properly”.
    1
  19. Depends on the error.
    1
  20.  @ahasibrifat7568  Start by describing exactly what the error is.
    1
  21.  @ahasibrifat7568  “unable to get local issuer certificate” sounds like something you should look into.
    1
  22. Demand your money back.
    1
  23. If your tasks are not CPU-bound, then asyncio would make things simpler because it greatly reduces the opportunities for race conditions.
    1
  24. I don’t know why people are so scared of SQL injection attacks. Properly escaping values in standard SQL is as easy as def sql_string(s) : "returns an SQL string literal that evaluates to s⋅" if s == None : q = "null" elif isinstance(s, int) : q = "%d" % s elif isinstance(s, (bytes, bytearray)) : q = "X'" + ""⋅join("%02x" % d for d in s) + "'" elif isinstance(s, str) : q = "'" + str(s)⋅replace("'", "''") + "'" else : raise TypeError("can only convert bytes, str, int or None types") ♯end if return q ♯end sql_string
    1
  25. How would you use placeholders in, say, a list of values for an IN clause?
    1
  26. 16:25 Actually days of the week should numbered from 0, aren’t they?
    1
  27. If they didn’t know it at the time, is there any record of it actually happening?
    1
  28. 11:44 The situation you’re describing -- accessing an undeclared variable declared in an outer scope, followed by an assignment to it -- is a Python language error. So it cannot lead to “unexpected behaviour”. Python requires you to declare the variable as either “global” or “nonlocal” before it permits this sort of thing.
    1
  29. Remember that, in Python, functions are objects too.
    1
  30. The magic phrase is “lexical binding”. Any language that incorporates this feature automatically gains coolness points. You only lose a few if you do it in clumsy PHP style.
    1
  31. The largest Python project I built using a DBMS was about 15,000 lines. I’ve never used an ORM.
    1
  32.  @marcotroster8247  I still don’t see the need for one. I was looking back at the old code, and it still makes sense to me.
    1
  33. I have used both together.
    1
  34.  @comfuse  So feel free to offer an alternative.
    1
  35. Think of coroutines as an alternative to callbacks. Maybe you already have an event loop to handle multiple concurrent requests (pretty much mandatory in GUI programs, for example). Say you have a task which requires several steps, with waiting in-between for other tasks to do their part, and you don’t want to block the whole event loop while waiting. The conventional approach would be to break each step into a separate callback. As each callback ends, it queues the asynchronous request which invokes the next callback when done. This makes it harder to follow the logic between the separate steps. Making the task into a coroutine allows you to keep all the steps together in a single linear sequence.
    1
  36.  @zacharythatcher7328  Threads are not an alternative to callbacks. Threaded event loops (in fact, threaded everything) were all the rage in the 1990s, until it was realized that they made the code very hard to debug. That’s why we now stick to single-threaded event loops, select(2)/poll(2)/epoll(2) etc. But then, time-consuming tasks required the use of callbacks to maximize responsiveness, until the old technique of coroutines was revived more recently as a way to make such code more readable. This has required language changes, but a lot of languages (Python included) have adopted those changes. What Arjan is using threads for here, and what I have done with them myself, is to turn blocking calls into non-blocking ones. That’s all. Luckily, in POSIX, “blocking” normally means “thread-blocking”, not “process-blocking”. That’s why we can get away with it. Again, it’s all in the cause of maximizing responsiveness, without getting back into the hell of full-on multithreading.
    1
  37. The concept of relational databases arose from the mathematics of data relations. Remember what came before: there “hierarchical” databases (e.g. IBM’s IMS) and “network” databases, a.k.a. the CODASYL model (which some are now trying to revive in the form of “graph” databases). Both of these were very much tied up with on-disk structures and explicit indexing and linking and all the rest of it. So any changes to your database structures, even just wanting to optimize things a little, required changes to your code. Relational databases abstracted away from all these implementation issues, and helped a lot with decoupling code from low-level on-disk structures.
    1
  38. I think it would make sense with the upcoming “nogil” changes, and some of the potential backward-compatibility breakage, to start calling that the 4.x series.
    1
  39. Doesn’t the “Zen of Python” say that “flat is better than nested”? (Not that I pay attention to the “Zen of Python” anyway...)
    1
  40.  @blue_meets_blue  The CS term for that binding of names is the “environment”. In Python terms, “function” (code) + “environment” (data) = “function object” (code + data).
    1
  41. I sum this up in something I call Van Rossum’s Triangle: https://
    1
  42. ww
    1
  43. w.
    1
  44. devi
    1
  45. antart.
    1
  46. com/
    1
  47. default-cube/
    1
  48. art/
    1
  49. Van-Rossum-s-Triangle-
    1
  50. 67979
    1