There was eleven of us last night, so this is just the bits of
conversation I heard.

strace(1) is handy for looking at the system calls a program makes to
the kernel, try `groups' and then `sudo -i strace -tte file groups'.

Facebook's React has spread to Android and iOS.  "React Native lets you
build mobile apps using only JavaScript.  It uses the same design as
React, letting you compose a rich mobile UI from declarative
components." — https://facebook.github.io/react-native/

Python has descriptor classes;  those with __get__(), __set__(), and
others.  These functions get called when an instance of the class is in
another object's class dictionary.
https://docs.python.org/3/reference/datamodel.html#implementing-descriptors

    >>> class Desc():
    ...     def __get__(*a):
    ...         print('get:', *a)
    ...
    >>> class Foo():
    ...     a = Desc()
    ...
    >>> f = Foo()
    >>> f.a
    get: <__main__.Desc object at 0x7f4426523240>
        <__main__.Foo object at 0x7f4426523278>
        <class '__main__.Foo'>
    >>>

As well as duck typing, there's a convention in Python called, by some,
goose typing.  Built-ins isinstance() and issubclass() bow to a `check'
function, if it's defined, and that can use reflection to do the test.
https://docs.python.org/3/library/collections.abc.html
https://www.python.org/dev/peps/pep-3119/

    >>> from collections import abc
    >>> class Iter:
    ...     def __iter__(my):
    ...         raise StopIteration
    ...
    >>> issubclass(Iter, abc.Iterable)
    True
    >>> isinstance(Iter(), abc.Iterable)
    True
    >>> abc.Iterable.__instancecheck__
    <bound method ABCMeta.__instancecheck__ of <class 
'collections.abc.Iterable'>>
    >>> abc.Iterable.__instancecheck__(Iter())
    True
    >>> abc.Iterable.__instancecheck__(list())
    True
    >>> abc.Iterable.__instancecheck__(dict())
    True
    >>> abc.Iterable.__instancecheck__(set())
    True
    >>> abc.Iterable.__instancecheck__(open('/dev/null'))
    True
    >>> abc.Iterable.__instancecheck__(lambda: None)
    False

"Cython is an optimising static compiler for both the Python programming
language and the extended Cython programming language...  The Cython
language is a superset of the Python language that additionally supports
calling C functions and declaring C types on variables and class
attributes.  This allows the compiler to generate very efficient C code
from Cython code.  The C code is generated once" — http://cython.org/

"Coconut is a functional programming language that compiles to Python [2
or 3].  Since all valid Python is valid Coconut, using Coconut will only
extend and enhance what you're already capable of in Python...
range(10) |> map$(pow$(?, 2)) |> list" — http://coconut-lang.org/

Undebt is Python that uses the handy PyParsing library to re-factor a
tree of source code, mapping an old fragment of grammar to new, e.g. `x
= x + 1' to `x += 1' regardless of the complexity of the expression `x'.
It can be used for any language, but comes with Python-grammar
definitions.  A project could build up a set of transformations over
time that are repeatedly run to keep converting to the house style.
https://engineeringblog.yelp.com/2016/08/undebt-how-we-refactored-3-million-lines-of-code.html

gpg(1)'s -c is good for encrypting single files, rather than one of the
"zip" formats.  By default, it compresses the plaintext before
encrypting.

    $ dd if=/dev/zero bs=1k count=1k of=zeroes
    1024+0 records in
    1024+0 records out
    1048576 bytes (1.0 MB, 1.0 MiB) copied, 0.012425 s, 84.4 MB/s
    $ gpg -c zeroes
    $ du *
    1024    zeroes
    4       zeroes.gpg
    $

"memfd_create() creates an anonymous file and returns a file descriptor
that refers to it.  The file behaves like a regular file, and so can be
modified, truncated, memory-mapped, and so on.  However, unlike a
regular file, it lives in RAM and has a volatile backing storage.  ...a
simple alternative to manually mounting a tmpfs(5) filesystem and
creating and opening a file...  ...primary purpose... used with the
file-sealing APIs provided by fcntl(2)." — memfd_create(2)

Using a fractional number of bits per input symbol.  "arithmetic coding
encodes the entire message into a single number, an arbitrary-precision
fraction q where 0 ≤ q < 1"
— https://en.wikipedia.org/wiki/Arithmetic_coding

Persecution of a minority.

    gauche   Unsophisticated and socially awkward.
        Mid 18th century: French, literally ‘left’.
            — https://en.oxforddictionaries.com/definition/gauche
    dexterous
        Early 17th century (in the sense ‘mentally adroit’): from Latin
        dexter ‘on the right’ + -ous.
            — https://en.oxforddictionaries.com/definition/dexterous
    sinister
        Late Middle English (in the sense ‘malicious, underhand’): from
        Old French sinistre or Latin sinister ‘left’.
            — https://en.oxforddictionaries.com/definition/sinister
    cack handed   derogatory   Left-handed.
        Mid 19th century: from cack, in the sense ‘excrement’, + hand + -ed.
            — https://en.oxforddictionaries.com/definition/cack-handed

Patterns on Rubik's cube.
    http://www.cflmath.com/Rubik/patterns.html
    The Superflip.
        U R2 F B R B2 R U2 L B2 R U' D' R2 F R' L B2 U2 F2
    https://ruwix.com/the-rubiks-cube/rubiks-cube-patterns-algorithms/

Cheers, Ralph.

-- 
Next meeting:  Bournemouth, Tuesday, 2017-09-05 20:00
Meets, Mailing list, IRC, LinkedIn, ...  http://dorset.lug.org.uk/
New thread:  mailto:[email protected] / CHECK IF YOU'RE REPLYING
Reporting bugs well:  http://goo.gl/4Xue     / TO THE LIST OR THE AUTHOR

Reply via email to