Home

- Was the election stolen?
You want yes or no? (Depends on your US partisan politics)
- What house is Harry Potter? Gryffindors or "None because he doesn't exist"

Our epistemology is driven by rules about group membership (state that you believe this or we will ruin your life) and cultural references.

Should we be surprised that the bot copies us and doesn't role play a sci-fi trope when no one asked the bot to roleplay a sci-fi trope?

I think if there was an integration test tool, it would:
- Have 1 tool per thing that holds state (db, redis, file system)
- That tool would reset state between runs

(Fixtures exist but those are place you can put code, not the code that goes in a fixture)

Now I'm going to go search pypi and see if this idea has already been done 25 times

Another thing about integration tests is the add more test statuses

- code is bad (failed test)
- server wasn't available (code is indeterminate quality)
- code is good (everything worked)

Because of the indeterminancy, integration tests need to be separated from pure unit tests & run on a different interval & have a different policy when they are indeterminate, cf pure unit test failures which should always fail the whole build.

If people want to run a regional pycon in a state where the culture wars swing the other way, it is a big club. Heck there are even pycon in places where American culture wars are not a thing, where people are arguing about something else.

This joke could have benefited from some code review and unit tests.

One theme was "Things aren't going to improve until a developer who has lived through the pain is promoted and does something about it"

---
(me: Who owns a sentient document?)
AI generated code... is it patentable? Is it copyrightable?

Patents on executing an algorithm are getting harder to defend.
---
Software code is a "Literary Work" for purpose of copyright.
---
Google vs Oracle on APIs expression is covered by copyright but ideas are not.
---

Licensing might matter as much as copyright law
- proprietary, public domain, copyleft or permissive OS
- google page rank is patented but expired (public domain)
License law built on top of copyright/only enforceable because copyright law exists.

Copyleft
- weak - ... (undefined)...
- strong GNU - derivatives must use same license (or more restrictive). Enforced by SFC vs proprietary commercial companies. SFC has standing because they are the intended beneficiary. (i.e. Companies violate GNU because, hey what is that nerd going to do)

Authorship
- e.g. can who is the author for a prompt that create a cool app?
- Author is AI! AI can't be a copyright holder. Monkey-self law governs here (no kidding!). Only human authors can be authors.

me: I'm still listing ChatGPT in AUTHORS.md

Zarya of the Dawn got cancelled:

https://publicrecords.copyright.gov/detailed-record/34743281?associatedRecords=Kashtanova,%20Kristina

Training data is black box & could be copyrighted content or any license you can think of. Could have direct infringement (accidentally encoded a copy into the LLMs weights). Being fought in court right now.

Is output a copyright infringement? Already decided that unrelated text is not infringement, but identical regurgitation is? could be?

Is it fair use?
- Transformation. 2 court cases say that LLM is transformation. (google book scan case applies here). Google v Oracle - google made a new language in a new environment so it was okay transformative fair use.
- Economic impact. Unclear that there isn't a negative impact on the creator. 25+ cases about this in court.

Advice
- use code you understand
- follow same advice as for using any 3rd party code (similar concerns)
- small pieces are safer (i.e. even if sort of a copy)
- larger is safe if it isn't a copy of something

Use automated tools (too find accidental verbatim copies?)
Documentation - Show what is AI created.
Get AI/LLM company to indemnify you

To register a copyright, you need to make (some sort?) of effort to identify AI code and to exclude it from copyright.

Use SCA tools:
e.g. https://github.com/magnologan/awesome-sca

LLM hosting companies have limits on their indemnification clauses.

You might need to block "public code suggestions" in github copilot: ref: https://docs.github.com/en/copilot/configuring-github-copilot/configuring-github-copilot-settings-on-githubcom

Scenarios for using openstreet map
- small - Using open street maps of Sterling, VA to reveal what resources are in a virtually gated neighborhood
- impactful - During the earthquake in Haiti people contributed to openmap got used by search & rescue teams.

https://www.openstreetmap.org

Working on the supply chain problem using crowd sourced info

(Can't tell if your materials are participating in illegal activities if you don't know where it came from)

https://opensupplyhub.org

GIL is not locked during I/O. Waiting can be parallelized.
---
asyncio.run() handles the event loop

Codspeed.... sounds fishy...what's that

https://codspeed.io/

Runs in process like sqlite does (but not inmemory, can be saved to file/page out)
MIT license
Uses modern tricks to run very fast
Easy enough for non-specialist

me: sounds like it is for supporting "data frame oriented programming"
---
SQL (postgres) poorly optimized for big data
Analytic dbs poorly optimized for installing the whole thing on your laptop
---
duck db tries to be an analytics db that works well on a workstation (local processing instead of sending data across network for a sql db to work with it)

duckb syntax is postgres-like
Pivot/unpivot features
... many features new to me...

GROUP BY ALL, SORT BY ALL, syntactic sugar to avoid listing lots of columns

Duckdb will query a dataframe in the current variable scope with SQL as if it was a table.

Whoa....

Duckdb can load/expert data fast...
Has ecosystem integrations (all the dataframe libraries, not just pandas)
Supports "Relational API" (what?) and SQL.

ah Relational API https://duckdb.org/docs/api/python/relational_api.html

You can simulate working with pyspark using duckdb on your workstation.... I wonder if this will simulate AWS Glue close enough?

Pydantic will be selling an observability tool.
---
Why python + rust? (me: python is slow, duh)
Rust apps force developer to think about `panic` s
Rust is a more secure option than c/c++ for native coding with python

Rust has novel solution for concurrency. (the borrowing/ownership thing I think)
Rust has borrowed features from modern languages like python
---
PyO3 with maturin let's you call rust from python or call python from a rust app.

Slap this on your rust function
`#[pyfunction]` and C code will be generated to compile it to an extension. (py03 makes the C, maturin compiles the C.... I think)

`import b` will import b.pyd using the ABI the same as if it were `b.py`
Cython *et al *do the same thing.
----
In 2 years, 1/2 of new packages using native code will be using Rust instead of C/C++

Rust to python cheat sheet, they are similar
---
def - fn
str - &str
int - usize
let mut - (initialization)
return - (last line in function is return)

Expect 2 to 4x speedup without trying. (me: even on string intensive code & no particular math?)

Continuous benchmarking (CI tools) needs bare metal machines or you get to too much noise from non-code reasons for the thing being fast/slow

Bare metal/non-shared CI machines are expensive.

(Sounds pessimistic about the possibility of perf testing side projects or in a corporate shared build server)

Scenario: What if we had a stream of dicts (a discriminated union) with a union with Any....

Option 1- if/elif on the discriminator field
Option 2- Add a `match` statement that won't be recognized by subsequent maintainers of the code base.

TypeAdapter an undefined concept.

https://docs.pydantic.dev/latest/api/type_adapter/

"Type adapters provide a flexible way to perform validation and serialization based on a Python type." ah, yes. Flexible.

Here is the official tutorial

https://peps.python.org/pep-0636/

Composability is a good design goal. It needs to be effortless/seamless.

Impediments to this:
GOTO- Single entry/exit helps composibility
modulelack- i.e. code polluting the global namespace
inheritance- breaks encapsulation
error handling -.....

Batch languages didn't need error handling. Either that batch succeeded or it failed. Only matters in realtime code.
Global error handlers created race conditions.
Some OSs tried to handle error handling on behalf of the app (app error handlers and "resumptions") - Crazy idea!

Exceptions should be part of language not the OS. Domain concerns.
Standard way to report errors. Errors harder to ignore. App now has possibility to recover.

Exceptions don't scale. They work poorly with the typesystem. (huh?)

Shadown type system in C++/java called "exception specifications" failed. (What? I don't know what these are) Deprecated in C++.

Okay I'll have to look that up.

Exception conflate categories of errors:
- recoverable errors, e.g. try again
- unrecoverable errors (panic!)

Because they're the same, recoverable errors are unnecessarily expensive.

Exceptions destroy partial calculations (waste compute)
Maybe instead return a union of Error and the Answer.

me: I hate coding against unions. Will we hear why suddenly Unions are good?

Everything returns a union or collection of unions and you use pattern matching for handling every result that could error-out. So maybe replace try/except/finally with switch statements?

Risk of Union types is the calling code ignores the Error, e.g. if return Tuple[Answer,Error]

You can do this style of error handling with `returns`

https://pypi.org/project/returns

`@safe` decorator will make a ordinary function return Results (unions of answer/error) . I think.

@safe Use `bind` function to chain/compose many functions that all use these Union Result types.

`do` notation uses comprehension notation to chain/compose functions with multiple args. I think.

@safe Type checker now tells us if an exception ignored. Maybe. Not clear if mypy can handle this pattern/library.

@safe Rust, Kotlin, newer C++ already do this style of error handling.

I guess this is handy if you want to make sure no exception causes a crash w/o resorting to a global error handler

@safe This is the repo for the sample code from the talk

https://github.com/BruceEckel/functional_error_handling

`pip-init` is for setup.py

https://pypi.org/project/pip-init/