From 8cfe656fbb312398244d6f0e820d4f179db3cfc7 Mon Sep 17 00:00:00 2001 From: Kévin Le Gouguec Date: Thu, 11 Jul 2019 18:10:53 +0200 Subject: Move some things around --- reviews/articles.md | 76 ++++++++++ reviews/blog-roll.md | 114 +++++++++++++++ reviews/linux.conf.au-2017.md | 330 ++++++++++++++++++++++++++++++++++++++++++ reviews/linux.conf.au-2018.md | 136 +++++++++++++++++ reviews/mailing-lists.md | 68 +++++++++ reviews/talks.md | 81 +++++++++++ 6 files changed, 805 insertions(+) create mode 100644 reviews/articles.md create mode 100644 reviews/blog-roll.md create mode 100644 reviews/linux.conf.au-2017.md create mode 100644 reviews/linux.conf.au-2018.md create mode 100644 reviews/mailing-lists.md create mode 100644 reviews/talks.md (limited to 'reviews') diff --git a/reviews/articles.md b/reviews/articles.md new file mode 100644 index 0000000..82dc7ee --- /dev/null +++ b/reviews/articles.md @@ -0,0 +1,76 @@ +# Phillip Rogaway - The Moral Character of Cryptographic Work + +:::: tags +- Cryptography +- Society +:::: + +An appeal to cryptographers to ponder on the [Russell-Einstein +manifesto], consider the moral implications of their work, take a step +back from "crypto-for-crypto", and focus on "crypto-for-privacy" (or, +to name the threat more explicitly, "anti-surveillance research"). + +Harps on FBI Director James Comey's "law-enforcement framing": + +> 1. Privacy is *personal* good. It's about your desire to control +> personal information about you. +> 2. Security, on the other hand, is a *collective* good. It's about +> living in a safe and secure world. +> 3. Privacy and security are inherently in conflict. As you +> strengthen one, you weaken the other. We need to find the right +> *balance*. +> 4. Modern communications technology has destroyed the former +> balance. It's been a boon to privacy, and a blow to security. +> Encryption is especially threatening. Our laws just haven't kept +> up. +> 5. Because of this, *bad guys* may win. The bad guys are +> terrorists, murderers, child pornographers, drug traffickers, and +> money launderers. The technology that we good guys use - the bad +> guys use it too, to escape detection. +> 6. At this point, we run the risk of Going Dark. Warrants will be +> issued, but, due to encryption, they'll be meaningless. We're +> becoming a country of unopenable closets. Default encryption may +> make a good marketing pitch, but it's reckless design. It will +> lead us to a very dark place. + +This framing is dismissed as "inconsistent with the history of +intelligence gathering, and with the NSA's own mission statement", +without further explanation. + +I wish the author had spent some prose explaining how exactly this +framing is fallacious. There is a footnote providing some references, +but as far as I can tell these references mainly reinforce the point +that the NSA's surveillance methods are a threat to privacy; it is not +obvious how "the NSA overreaches" contradicts "it's harder to catch +bad guys once they get better crypto". + +For what it's worth, I found that [Aaron Brantly's +article](#aaron-brantly---banning-encryption-to-stop-terrorists-a-worse-than-futile-excercise) +does a better job at showing the shortsightedness of this line of +reasoning, as does this footnote: + +> When crypto is outlawed only outlaws will have crypto. + +[Russell-Einstein manifesto]: https://en.wikipedia.org/wiki/Russell%E2%80%93Einstein_Manifesto + +# Aaron Brantly - Banning Encryption to Stop Terrorists: A Worse than Futile Excercise + +:::: tags +- Cryptography +- Society +:::: + +The debate can be phrased as follows: + +> Is increasing security in one narrow area worth degrading it in +> every other? + +Answering "yes" overlooks two things: + +1. Weakening officially distributed encryption will not impact + terrorists, who will simply move to new, unregulated platforms. + +2. Once they have done that, we end up in a situation where lawful + citizens are stuck with insecure communication channels, and + terrorists are the only ones benefiting from state-of-the-art + confidentiality/integrity/authenticity. diff --git a/reviews/blog-roll.md b/reviews/blog-roll.md new file mode 100644 index 0000000..a56cc6c --- /dev/null +++ b/reviews/blog-roll.md @@ -0,0 +1,114 @@ +This is a list of blog-ish websites where I found insightful stuff +that I would like not to forget. + +# [LispCast] + +Eric Normand's musings on programming paradigms and their application, +with a soft spot for functional programming. + +[When in doubt, refactor at the bottom] +: Quoting Sandi Metz: + + > Duplication is far cheaper than the wrong abstraction. + + The point being that blindly following the letter of the DRY law + can lead developers to add complexity to extracted functions + because "it almost does what I want; if I could add just one more + parameter to it…". + + Normand and Metz encourage developers to "mechanically" extract + small pieces of logic; even if they are not re-usable, bundling + things together and naming them helps make the potential + abstractions more visible. + +[Programming Paradigms and the Procedural Paradox] +: A discussion on our tendency to conflate *paradigms* with their + *features*; for example, when trying to answer "can this language + express that paradigm?", we often reduce the question to "does + this language possess those features?". + + Normand wonders whether we do this because the procedural + paradigm's metaphor (a series of steps that each may contain any + number of sub-tasks) maps so well to its features (sequential + statements, subroutines) that it trained us to mix those up. + +[LispCast]: https://lispcast.com/category/writing/ +[When in doubt, refactor at the bottom]: https://lispcast.com/refactor-bottom/ +[Programming Paradigms and the Procedural Paradox]: https://lispcast.com/procedural-paradox/ + +# [null program] + +Chris Wellons's in-depth looks into a fairly wide range of programming +techniques and applications. The articles often come with +illustrative code samples, which are always broken down into +bite-sized chunks that are easy to grok. + +Some recurring topics I enjoy reading about: + +- GNU/Linux plumbing + - [Raw Linux Threads via System Calls] + - [Appending to a File from Multiple Processes] + - [A Magnetized Needle and a Steady Hand] + +- C programming tricks + - [Global State: A Tale of Two Bad C APIs] + - [C Closures as a Library] + - [How to Write Portable C Without Complicating Your Build] + - [A Tutorial on Portable Makefiles] + +- Algorithmics + - [Inspecting C's qsort Through Animation] + - [A Branchless UTF-8 Decoder] + - [Render Multimedia in Pure C] + +- Emacs Lisp plumbing + - [Some Performance Advantages of Lexical Scope] + - [What's in an Emacs Lambda] + +[null program]: http://nullprogram.com/index/ +[Raw Linux Threads via System Calls]: https://nullprogram.com/blog/2015/05/15/ +[Appending to a File from Multiple Processes]: https://nullprogram.com/blog/2016/08/03/ +[A Magnetized Needle and a Steady Hand]: https://nullprogram.com/blog/2016/11/17/ +[Global State: A Tale of Two Bad C APIs]: https://nullprogram.com/blog/2014/10/12/ +[C Closures as a Library]: https://nullprogram.com/blog/2017/01/08/ +[How to Write Portable C Without Complicating Your Build]: https://nullprogram.com/blog/2017/03/30/ +[A Tutorial on Portable Makefiles]: https://nullprogram.com/blog/2017/08/20/ +[Inspecting C's qsort Through Animation]: https://nullprogram.com/blog/2016/09/05/ +[A Branchless UTF-8 Decoder]: https://nullprogram.com/blog/2017/10/06/ +[Render Multimedia in Pure C]: https://nullprogram.com/blog/2017/11/03/ +[Some Performance Advantages of Lexical Scope]: https://nullprogram.com/blog/2016/12/22/ +[What's in an Emacs Lambda]: https://nullprogram.com/blog/2017/12/14/ + +# [Et tu, Cthulhu] + +[A hash table re-hash] +: A benchmark of hash tables that manages to succinctly explain + common performance issues and tradeoffs with this data structure, + to show results across a wide range of implementations, and to + provide very understandable interepretations for those results. + +[Et tu, Cthulhu]: https://hpjansson.org/blag/ +[A hash table re-hash]: https://hpjansson.org/blag/2018/07/24/a-hash-table-re-hash/ + +# [Evanmiller.org] + +I mostly only read the articles dealing with programming languages. +The down-to-earth commentary made me feel like the author both +appreciates the thought process that went into the design, and has +enough hindsight to find where that thought process fell short. + +[A Taste of Rust] +: An overview of some of the language's features. Some comments + resonated particularly well with me, e.g. on nested functions: + + > With other languages, I’m never quite sure where to put + > helper functions. I’m usually wary of factoring code into + > small, “beautiful” functions because I’m afraid they’ll end + > up under the couch cushions, or behind the radiator next to + > my car keys. With Rust, I can build up a kind of organic + > tree of function definitions, each scoped to the place where + > they’re actually going to be used, and promote them up the + > tree as they take on the Platonic form of Reusable Code. + +[Evanmiller.org]: https://www.evanmiller.org/ +[A Taste of Rust]: https://www.evanmiller.org/a-taste-of-rust.html diff --git a/reviews/linux.conf.au-2017.md b/reviews/linux.conf.au-2017.md new file mode 100644 index 0000000..9eb8da7 --- /dev/null +++ b/reviews/linux.conf.au-2017.md @@ -0,0 +1,330 @@ +# linux.conf.au 2017 + +## General comments + +Re-stating the audience's questions before replying is helpful. + +## Choose Your Own Adventure, Please! + +Keynote by Pia Waugh. + +Warns against short-sighted itch-scratching; wants to encourage more +long-lasting systemic change. To contrast with Maciej Cegłowski, who +warns against [ivory-tower wank] in Sillicon Valley, where no-one +seems interested in working on the severe poverty problems nearby. + +(To be fair, Pia does say we need both "symptomatic relief" and +systemic change.) + +41:30 + +> My favourite story from my studies with martial arts was actually +> about two monks walking around. They're walking along, elder one, +> younger one, and when they get to the river, a person comes and says +> "I'm being chased by robbers, can you help me across the river +> please?". The older monk says "Yep, not a problem", picks them up +> and carries them across (because they're hurt). The person gets +> away. And they're walking along, still in silence, and the younger +> monk says: "… You know, back at the river back there"; the older +> monk says "Yeah?"; the younger monk says "I thought we had taken a +> vow of silence". The other goes, "Yeah?". "… Should you have +> spoken to that person?", and the older monk says: "I put that person +> down back at the river. Why haven't you?" + +That story appeals to me: it's got some sort of +Jesus-ish-unconditional-forgiveness-Zen vibe that feels reassuring, +"it's OK to make mistakes, as long as you aimed for the Greater Good, +focus on the Spirit of the Law instead of upholding the Letter". But +slippery slope turns that into "move fast and break things", +consequences and accountability be damned. + +You can even link that to ["fussy" compilers] and false alarms: why +should Buddhist GCC warn on Vow-of-Silence violation if it's not +actually a problem? The warning should be refined, the diagnosis +should be smarter, the standard amended, otherwise how do you +distinguish between the shades of red? + +["fussy" compilers]: https://lists.gnu.org/archive/html/emacs-devel/2016-04/msg00190.html +[ivory-tower wank]: http://idlewords.com/talks/superintelligence.htm + +## Stephen King's practical advice for tech writers + +By Rikki Endsley. + +Lots of pointers, e.g. [The Care and Feeding of the +Press](http://netpress.org/care-feeding-press/). + +Suggested outline: + +- intro (invite the reader in) +- state the problem (background) +- solution +- (for tech article, tutorial, whitepaper: technical stuff (howto, FAQ)) +- conclude (important dates, action items) + +Parasite words: "very", "some". Be mindful of slang. + +## Sharing the love: making games with PICO-8 + +By John Dalton. + +> Sad old people, longing for the glory days + +PICO-8 restores the "Democracy of Creating". + +Kids get the point of sharing without having to be "encouraged" by +licences. + +## Writing less, saying more: UX lessons from the small screen + +By Claire Mahoney. + +- "mobile" is not necessarily "on the move" +- a "mobile" app does not have to be a "diet" version of the original + +Users do not expect the functionality to be diminished. + +> Context can be better than words + +(I feel like there is a connection to be made here with namespaces in +programming languages.) + +Patterns are good, repetition is not. + +Defining purpose with "when X, I want Y so I can Z" helps "keeping it +real" and reminding you of the user out there. + +## Mamas Don't Let Your Babies Grow Up to Be Rock Star Developers + +By Rikki Endsley. + +When writing job descriptions, stop asking for rock stars. Focus on: + +- job requirements +- job environment + +Makes it easier for people to figure whether they will fit in. + +Look for developers interested in making *others* succeed, learning +*new* skills; make sure they are accessible, they use the best tool +for the job, and they are able to innovate, lead, and collaborate with +a diverse mix of people. + +If you have a rockstar on your hands, make sure the janitors still get +some credits. + +## Why haven't you licensed your project? + +By Richard Fontana. + +"Post open-source" has actually been a thing for a while: the term +describes the widespread trend of not attributing a license to one's +project. + +Berne convention says that copyright is automatic, so this POSS +software might be implicitly "proprietary". Why worry? There is a +lot of proprietary software already. + +Not putting on a license constitutes a statement for some developers. + +Some attempts at public-domain dedication: + +- [WTFPL](http://www.wtfpl.net/) +- [Unlicense](http://unlicense.org/) +- [0-clause BSD](http://landley.net/toybox/license.html) +- [BOLA](https://blitiri.com.ar/p/bola/) +- [CC0](https://creativecommons.org/share-your-work/public-domain/cc0/) + +## Handle Conflict, Like a Boss! + +By Deb Nicholson. + +Conflict mostly comes from missing information, mismatched goals. + +Avoidance, accomodation and assertion each have their own issues as +conflict-handling strategies. + +Using historical motivations can help give credit to new ideas. + +Hypotheticals such as "What's the worst that could happen?" help +identify the root issues people will not directly talk about. + +No ad hominem. No name-calling. Period. Beware of [Contempt Culture]. + +Setting expectations can help enforce a civil tone and constructive +criticism. + +[Contempt Culture]: (https://blog.aurynn.com/2015/12/16-contempt-culture). + +## The journey of a word: how text ends up on a page + +By Simon Cozens. + +Very interesting explanations on the lengths Unicode must go to in +order to turn humanity's sprawling mess of written communication +methods into rigorous rules that a computer can understand. + +Some diacritics can be encoded either with a single code point or a +vowel plus a combining code point; this is because Unicode intends to +have one code point for *every character that other encodings have +ever contained*. + +Cozens is publishing a free online book on the subject: [Fonts and +Layout for Global Scripts]. + +[Fonts and Layout for Global Scripts]: https://simoncozens.github.io/fonts-and-layout/ + +## Surviving the Next 30 Years of Free Software + +By Karen Sandler. + +Is copyright assignment to big organizations (Canonical, FSF?) the +solution to problems we cannot anticipate? + +Wills are tricky: recipients might be taxed on the "monetary value" of +the "legacy". + +Using a trust as a "legal hack": would build a "registry" of free +software; the trust can map handles to contact information to preserve +anonymity. + +The idea is vaporware for now, since this trust cannot be built +without debating a lot of finer points. + +> The best gift you can give to the people you love is to make sure +> they're prepared for when you're gone. + +## The relationship between openness and democracy + +By Pia Waugh. + +Openness creates a natural incentive for "doing the right thing". + +Some people think shady deals which allow politicians to make huge +amounts of money from the industry are fair game, since they have to +get the investments they made during their campaign back. + +On "policy-based evidence" as an alternative to evidence-based policy: + +> That's rather funny'n'clever'n'witty… Oh shit, you're serious. + +How representative and legitimate are elected individuals? Never mind +the participation rate, most people vote for (or against) one or two +things, not the whole program. + +> (13:00) Everyone loves to kick public servants; **everyone**. + +> (14:30) I was gonna start a cartoon. And the first thing was gonna +> be someone saying "I'm surprised that you're working in government, +> I would've thought you'd disagree with X, Y, Z." OK. +> +> The second panel somone saying to me "I just can't believe you're +> working in government! I thought you had *integrity*! I thought +> you would disagree with all of these things!" … *OK*. +> +> The third person says "YOU MOTHER-"… Anyway, goes on a complete +> tirade, I'll probably get hit on the head. +> +> The fourth panel is me running off in the distance. Into the +> sunset. And the three people saying to each other "Why are there no +> good people in government?" + +"Consulting the public" used to be a point on a checklist, not +intended to yield useful outputs. + +## JavaScript is Awe-ful + +By Katie McLaughlin. + +In JavaScript, functions have to add `var` explicitly to their local +variable declarations, otherwise they will assign to global variables. + +``` javascript +> [] + [] +"" +> [] + {} +[object Object] +> {} + [] +0 +> {} + {} +NaN +``` + +JavaScript is a registered trademark; ECMAScript is the actual, +*standardised*, **versioned** language. + +Some examples of things which can be accomplished without JavaScript: +. + +Cross-compilers alleviate some of the pain; one has to be careful with +their prefered language's warts though. + +In Ruby, `&&` and `and` do not have the same precedence with respect +to `not`. + +## Data Structures and Algorithms in the 21st Century + +By Jacinta Catherine Richardson. + +Voronoi diagrams have a lot of applications: + +- modeling the capacity of wireless networks +- robot navigation +- mouse hoverstate + +Fourier transforms help with data compression. Naively: O(n²); from +the sixties onward: O(n log(n)). Nearly Optimal Sparse Fourier +Transform (2012): O(k log(n)), helps on-the-fly data compression. + +Singular Value Decomposition helps with pattern recognition/comparison +by allowing to express e.g. rotations. + +> New stuff! + +Evolutionary algorithms (a form of AI/machine learning) to find +optima: + +- a function to tell "is this good enough?" + +Genetic algorithms (a form of evolutionary): + +- fitness criteria +- swap information ("breed") +- random-ish variations + +> Setting up the fitness criteria and the initial conditions for +> genetic algorithms […] is as much art as it is science. + +Artificial Immune Systems (90s) is used in computer security. + +Swarm algorithms: agents share the value of their findings and +converge. Used e.g. to locate cancer; considered for e.g. traveling +sales person problem, unmanned cars. + +Bacterial Foraging Optimization; Shuffled Frog Leaping; +Teaching-Learning-Based Optimisations. + +[Foldit](http://fold.it) is an experiment consisting in making humans +solve hard problems (e.g. protein folding) through competitive gaming. + +Graph isomorphism is *hard*. Easy to verify, hard to solve. Until a +week ago: we can now solve them in quasi-polynomial time. + +## My personal fight against the modern laptop + +By Hamish Coleman. + +Ports, durability, keys are getting worse. + +Plugging an older keyboard on newer Thinkpads presents issues: + +- the motherboard sends in high-voltage current to enable backlight +- some keys don't work; the firmware must be changed (and then + re-encrypted) + +Sharing firmware patches is challenging; most end-users have no idea +what these even are; some of them run Windows and cannot easily use +the patching tools. + +Newer firmwares seem to be signed; this will probably make them harder +to tweak. diff --git a/reviews/linux.conf.au-2018.md b/reviews/linux.conf.au-2018.md new file mode 100644 index 0000000..657bb64 --- /dev/null +++ b/reviews/linux.conf.au-2018.md @@ -0,0 +1,136 @@ +# linux.conf.au 2018 + +## Making Technology More Inclusive Through Papercraft and Sound + +By Andrew Huang. + +I like how the talk goes over a range of cross-domain topics: + +- high-level motivations + +Improving inclusiveness is necessary to make open-source actually +empower people; right now a very small subset of the population is +computer-savvy enough to take advantage of it. If the situation does +not improve, a handful of developers will hold a lot of power over +lots of alienated users, and lawmakers may resort to "preposterous" +solutions to attempt to regain control, e.g. license bonds for +software developments. + +- Kickstarter campaign management +- design choices & rationale + - "China-ready" + - "patience of a child" constraint +- gory hardware details +- the end result + +## QUIC: Replacing TCP for the Web + +By Jana Iyengar. + +Starts by introducing impressive application performance improvements, +although where were those measured? E.g. rural areas? + +Advantage that can already be inferred from the layer view: QUIC needs +fewer handshakes than TCP+TLS. + +Achieves 0-RTT when the server's cryptographic credentials are known. + +Supports "stream multiplexing": the upper layer (e.g. HTTP) can +transfer multiple objects independently in a single connection. +Losing part of one object does not block the others: retransmission is +managed at the stream level, not at the connection level. + +On top of UDP: allows userspace (Chrome) implementation. + +> If you think of layers as a set of functions, things that you want +> done, UDP is not a transport protocol. + +I.e. UDP does not provide reliability, same-order delivery… + +Jana was "in the SCTP bandwagon". + +They actually have *better performance improvements* for *bigger +latencies*? Nice. + +> § QUIC improvements by country + +👏 + +(Of course the end goal is probably to make sure regions with poor +connections do not miss out on the adfest; still, these remain welcome +technical improvements) + +Transport headers are encrypted to prevent "middlebox ossification". +They left a *single* byte unencrypted (the flags byte): this allowed +middleboxes to observe that it kinda had the same value on most +connections, assume that this was a "nominal" value, and block traffic +when this value differed. + +## You Can't Unit Test C, Right? + +By Benno Rice. + +- Mentions [Check](https://libcheck.github.io/check/) and + [Kyua](https://github.com/jmmv/kyua). +- Factor your boilerplate into libraries, especially the ugly hacks. +- Keep `main` small so that you don't need to test it so much. + +## Changing the world through (fan-)fiction + +By Paul Fenwick. + +Reading fiction is a convenient way to get us to think through +concepts we had not considered before. By re-purposing a familiar +setting, *fan*fiction lowers the barrier to entry to the writing +exercise: it makes it easier for the writer to get their point across +and to reach their audience. + +Some recommendations: + +- The Last Ringbearer +- [My Little Pony: Friendship is Optimal] +- [Harry Potter and the Methods of Rationality] + +Our media teaches us what is normal. Hence fiction opens up ways to +improve the status quo by acquainting us to new ideas. + +Another recommendation: Steven Universe. + +Mainstream and folklore stories feature a fair amount of unhealthy +relationships; this is problematic because repeated exposure helps +normalization[^I find that SMBC is a positive example of this effect: +it regularly (and, AFAICT, fairly randomly) features gay couples in +comics where the joke is *not* about homosexuality]. + +In Japan, doujinshi is considered normal and "adding value to the +brand", whereas similar things are flagged as "copyright infringement" +in other countries. + +[My Little Pony: Friendship is Optimal]: https://www.fimfiction.net/story/62074/Friendship-is-Optimal +[Harry Potter and the Methods of Rationality]: http://www.hpmor.com/ + +## Lessons from three years of volunteering to teach students code + +By David Tulloh. + +Takeways: + +1. Volunteering in schools is easy and fun. +2. We should care about what is taught in schools. +3. We should get involved and support schools teaching IT. + +CSIRO: Australian program to get professional developers to teach in +schools. + +[Pixees](https://pixees.fr/) seems to be a French equivalent. + +Tried to move students from "programmers" to "developers" by evoking: + +- automated testing +- version control +- bug tracking +- code review + +An audience member noted that while programs ala CSIRO are helpful, +this should be organized at the government policy level. + diff --git a/reviews/mailing-lists.md b/reviews/mailing-lists.md new file mode 100644 index 0000000..c63d376 --- /dev/null +++ b/reviews/mailing-lists.md @@ -0,0 +1,68 @@ +# Emacs + +## 2019-01 + +### [Apropos 54f297904e0c: Temporarily comment out CC Mode from tests which are incompatible with it.][cc-mode/electric-pair] + +A thread that feels very representative of the friction between +"keeping things working as they always did" vs. "simplifying that huge +lumbering beast of a codebase". I find [Stefan Monnier's +intervention][cc-mode/electric-pair-stefan] helpful because it +captures both sides of the argument quite well: + +> >> I understand that there's a transition needed between these two and this +> >> intermediate state can require more work, but it's important to keep the +> >> long term goal in mind when designing the current solution. +> > Whose long term goal? +> +> At the very least mine. +> +> > My goal, both long and short term, is to keep CC Mode +> > working properly. +> +> That's orthogonal. +> +> To give you a similarly general goal, my own goal is to make it so that +> **any feature which makes sense in many major mode be implemented once and +> then used in the relevant major modes, rather than being implemented +> independently for those major modes.** +> +> This is both for uniformity between major modes, and because it both +> simplifies and improves many major modes (which would otherwise either +> not provide the feature or only in very primitive ways). +> +> **And those maintainers like you who did go to the trouble of being early +> implementers of the feature suffer through the pain of having to adapt +> their code once the generic version of the feature becomes available.** +> Sometimes even at the cost of having the new feature working slightly +> worse in some corner cases. +> +> But many of them are quite happy to be able to drop their old code and +> get rid of that responsibility (i.e. bug reports about regressions can +> be redirected to Emacs maintainers). + +On a non-technical note, this thread allowed RMS to advertise the [GNU +Kind Communications Guidelines][gnu-kind-communication]: + +> To ask "who started it" is to oversimplify. Often what happens +> is that a little harshness creeps into a discussion, then people +> react to that in a way that is a little more harsh. So nobody +> "started it" but multiple people exacerbated it. +> +> **Thus, part of the effort is, when we feel harshness coming at us, +> to damp it down rather than hitting back.** + +[cc-mode/electric-pair]: https://lists.gnu.org/archive/html/emacs-devel/2019-01/msg00360.html +[cc-mode/electric-pair-stefan]: https://lists.gnu.org/archive/html/emacs-devel/2019-01/msg00518.html +[gnu-kind-communication]: https://www.gnu.org/philosophy/kind-communication.html + +### [Documentation about the completion framework][completion-documentation] + +Helpful pointers for whoever wants to dig into completion plumbing. +Personally, I struggled to get to grips with it when [debugging some +`icomplete` issue][icomplete-issue], relying on the source for +information, and giving up while trying to write an automated test +case. + +[completion-documentation]: https://lists.gnu.org/archive/html/emacs-devel/2019-01/msg00504.html +[icomplete-issue]: https://gitlab.com/peniblec/memory-leaks/commit/dcc0c05dc1f6a22645bf9355b72aa44b49776620 diff --git a/reviews/talks.md b/reviews/talks.md new file mode 100644 index 0000000..ed272c8 --- /dev/null +++ b/reviews/talks.md @@ -0,0 +1,81 @@ +# Sandi Metz - Nothing is Something + +:::: tags +- OOP +- Ruby +:::: + +Some insightful thoughts on OOP. + +Clever examples of message-passing to get rid of conditionals. + +Prefer composition with dependency injection to inheritance: +inheriting to override a method really means that the parent class had +a default "null" behaviour that can be injected explicitly. + +Name the role, make an interface for it, and make classes that +implement each behaviour (the null one and the specialiazed one). +This will make it easier to compose specializations (i.e. save you +from multiple inheritance). + + +# Sandi Metz - Rules + +:::: tags +- OOP +- Ruby +:::: + +Some theory-crafting on rule-following, then the actual rules, which +amount to + +- small classes, +- tiny methods, +- few parameters. + +At the 16-minute mark, an interesting interaction between Metz and a +programmer starting to apply these rules: the programmer wonders when +they will be able to understand the new application "the same way" +they understood the old one. I.e. will they ever reach a point where +they have a complete mental map of every interaction between every +object, the same way they used to have a complete mental map of the +old monolithic, sequential application? + +Metz's response is that nope, this will never happen; they will "cease +to care" instead. In exchange, they will be able to make localized +changes without worrying about breaking the whole application. + + +# Fred George - The Secret Assumption of Agile + +:::: tags +- Agile +- OOP +- programming methods +- project management +- training +:::: + +Advice on when to refactor: + +- *after* design, *before* writing unit tests for the new stuff: + prepare ground for the addition to fit right in; + +- *after* implementing the new behaviour, *before* integrating. + +Goes over the usual code smells taught during the training he gives +(conditionals, getters & setters, class names ala "Manager", too many +instance variables) + +Mentions a requirement for training "retention": skills must be +applied within a month after receiving the training, otherwise the +rationale will be lost. + +Questions: + +- Does he know of open-source projects that showcase this style of + programming? + - Smalltalk, some NodeJS libraries + +- Does he rely on naming conventions? + - Quite a lot. -- cgit v1.2.3