Log: 202209
Achievement
- Fluent Python (2nd ed.)
- read all! (about 1000 pages)
- this was really interesting book
- writing about python from the various perspective
- comparing with other languages
- applying various design patterns
- why python choose this syntax and language features, or why python doesn't do
- i could learn a lot of general language features, design patterns, architectures and the way to solve problems along with python's language philosophy
- reviewing the language from only one point of view is poor thinking
- there are a lot of fields where the language is used
- along with Essentials of Programming Languages, i knew that how python make it simple and easy to use by hiding low layer implementation such as pointers, treatment of strings, and resource management
- how easy to use string in python
- default utf-8 encoding, slice
- one of the most my favarite point is the syntax to create list and dict
[1, 2, 3]and{"x": 1, "y": 2}are almost diagrams- to realize what data is, we just look at it, never read it
- perceivability > readability
- after all, completely covering python code with type hints is reckless
- some packages, even pervasive ones, don't offer types enough
- errors of mypy and pylance are too annoying
- personally i want to stop using mypy
- annotate types every parameters and returns, even it's apparent, are bother; optional typing is best choice
- even variable name, docstring and comments are sufficient to give information of what data is
- forcing static typing may kill some advantage of python as dynamic language
- writing about python from the various perspective
- learned
- decorator using class with
__call__() - explicit use TypeAlias
- function singleddispatch
- typings python supports
- duck typing
- avoiding
isinstance() - using try-catch (EAFP; easier to ask for forgiveness than permission)
- <-> LBYL; look before you leap
- hmm i don't like this style lol
- but it seems that this style has advantage at concurrent programming
- avoiding
- goose typing
- using
isinstance()
- using
- static typing
- mypy
- static duck typing
- protocols
- duck typing
- favor object composition over class inheritance
- this was also said by JavaScript: The Definitive Guide
- variance rules of thumb
- if a formal type parameter defines a type for data that goes into the object after its initial construction, it can be contravariant (strict)
- if a formal type parameter defines a type for data that comes out of the object, it can be covariant (lenient)
- e.g. given
Callable[[ParamType, ...], ReturnType], each ParamType is contravariant and ReturnType is covariant
- with statement
-
It’s like factoring out the filling in a sandwich: using tuna with different breads. But what if you want to factor out the bread, to make sandwiches with wheat bread, using a different filling each time? That’s what the with statement offers.
-
- python doesn't implement tail recursion optimization (PTC; proper tail calls)
-
Personally, I think it is a fine feature for some languages, but I don’t think it fits Python: the elimination of stack traces for some calls but not others would certainly confuse many users, who have not been raised with tail call religion but might have learned about call semantics by tracing through a few calls in a debugger. - Guido van Rossum
-
- coroutines
- run event loop then manage coroutines in it
- passing control from one coroutine to another
- thus coroutine is the way to run the program concurrently in a sigle thread
- only one coroutine runs at a time
- pros
- no data corruption (vs. threads)
- no cost of memory and context switch (vs. processes)
- cons
- cannot be used for CPU-intensive jobs
- because only one coroutine runs at a time and it blocks the entire process
- use processes instead
- cannot be used for file I/O
- we can use
asyncio.to_thread()to avoid blocking the entire process
- we can use
- cannot be used for CPU-intensive jobs
- run event loop then manage coroutines in it
- descriptor
- the way to abstract away property definitions
- a class that implements a dynamic protocol consisting of the
__get__(),__set__(), and__delete__()methods
- a class that implements a dynamic protocol consisting of the
- methods in python are also descriptor!
-
Reading an attribute through an instance normally returns the attribute defined in the instance, but if there is no such attribute in the instance, a class attribute will be retrieved. On the other hand, assigning to an attribute in an instance normally creates the attribute in the instance, without affecting the class at all.
- the way to abstract away property definitions
- type class is a metaclass: a class that builds classes
- type is a subclass of object
- but at the same time object is an instance of type (what?!)
- decorator using class with
- some interesting references
- Strong Typing vs. Strong Testing
- Bad ideas in type theory
- Types considered harmful II
- Generics Considered Harmful
- Latency Numbers Ever Programmer Should Know
- Worse is Better
- this was said by The Unix Philosophy
- also, in Patterson & Hennessy's book: コンピュータの構成と設計,
-
優れた設計には適 度な妥協が必要である
- this is a principle about hardware design, but i think this is true to software too
-
- some wise words
-
Be conservative in what you send, be liberal in what you accept. - Postel's law, a.k.a the Robustness Principle
-
If you want the sum of a list of items, you should write it in a way that looks like “the sum of a list of items,” not in a way that looks like “loop over these items, maintain another variable t, perform a sequence of additions.” Why do we have high-level languages if not to express our intentions at a higher level and let the language worry about what low-level operations are needed to implement it? - David Eppstein’s
-
When I see patterns in my programs, I consider it a sign of trouble. The shape of a program should reflect only the problem it needs to solve. Any other regularity in the code is a sign, to me at least, that I’m using abstractions that aren’t powerful enough—often that I’m generating by hand the expansions of some macro that I need to write. —Paul Graham, Lisp hacker and venture capitalist
-
In Progreess
-
Essentials of Programming Languages
- Chapter 5. Continuation-Passing Interpreter
- learned how to optimize tail recursion
- if recursive function is tail recursion, it no longer need data stored within the current scope of the function for the next call
- the way passing control flow like data was really fresh idea to me, i had never think like that
- but i still have a question
- continuation-passing style actually doesn't leave the function on stack, which is waiting for the value returned from the function called in it
- but instead, continuations, which is a multi-nested closure, appear as arguments at a function call
- does this really work as optimization?
- Chapter 5. Continuation-Passing Interpreter
-
A Book of Abstract Algebra
- Chapter 5. Subgroups done!
- there are many terms that appear in A First Course In Graph Theory
- i've stopped reading it
- a lot of terminologies to which i'm not familiar
- very abstract
- boring
- maybe i should've learn abstract algebra first
- i wanna revenge after learning abstract algebra!
- i've stopped reading it
Stack
-
implement something in rust
- there is demand to rust in the company
- honestly i think typescript is the best choice for almost all of our product
- can write both frontend and backend
- maybe server-side react will come
- easy to learn and use
- good googlabiliity
- cost to learn rust and the strictness don't correspond with our products
- questionable to implement web apps in such a low-level language
- can write both frontend and backend
- but i wanna use rust if used go lang
- honestly i think typescript is the best choice for almost all of our product
- there is demand to rust in the company
-
Programming in Haskell
- putting aside good or bad, i like static typing and functional languages after all
- really fun to write program in them
- i wanna read again
- putting aside good or bad, i like static typing and functional languages after all
-
SQL Antipatterns: Avoiding the Pitfalls of Database Programming
-
Database Internals
-
Computer Organization and Design MIPS Edition: The Hardware/Software Interface (6th ed.)
Music
- Beautiful World / Utada Hikaru