0.3
workshops
Pycon 2019 Workshops
2019-06-05
2019-06-05
1
00:05
https://cfp.pycon.org.il/workshops/schedule/
2019-06-05T09:20:00+00:00
09:20
03:30
Room 1
workshops-130-making-your-python-code-write-your-python-code
https://cfp.pycon.org.il/workshops/talk/QQ3EKN/
false
Making your Python code write your Python code
Half day workshop (regular)
en
Discover Python's `ast` module to see how you can
analyze and generate Python code.
Have you ever wondered how much of your code could be generated automatically? Introspection, mutation, extension - Python's uber-dynamic nature allows us to do all kinds of kinky stuff. At this workshop, we will take a look at the 'ast' module and see how it allows us to analyze and produce Python code. By leveraging it's power, we will try to create some useful tools.
Marcin Sobczyk
2019-06-05T13:00:00+00:00
13:00
03:30
Room 1
workshops-94-let-s-write-a-lisp-interpreter
https://cfp.pycon.org.il/workshops/talk/CAMSAH/
false
Let's write a Lisp interpreter
Half day workshop (regular)
en
One of the best way to understand how programming languages work (including Python), is to implement one.
[Greenspun's tenth rule](https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule) states that `Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.`. Understanding how programming language work will make you a better programmer and gain a better understanding of Python itself.
We'll implement a small [lisp like](http://norvig.com/lispy.html) language and discuss language design & implementation issues and how they are found in Python.
- [Lexing](https://en.wikipedia.org/wiki/Lexical_analysis) & Parsing: What are the implication of Python using whitespace for indentation?
- Variable scope & [closures](https://en.wikipedia.org/wiki/Closure_(computer_programming)): Why we have `global` and `nonlocal` in Python
- Types: Why the value of `1/2` changed from Python 2 to 3
- Evaluating code: Python's `eval` vs `exec` and byte code interpreter. Why does `or` and `and` [short curcuit](https://en.wikipedia.org/wiki/Short-circuit_evaluation)
Miki Tebeka
2019-06-05T09:20:00+00:00
09:20
03:30
Room 2
workshops-174-creating-a-device-and-publishing-sensor-data-to-a-decentralized-cloud-using-aleph-im-and-micropython
https://cfp.pycon.org.il/workshops/talk/37T8MU/
false
Creating a device and publishing sensor data to a decentralized cloud using Aleph.im and MicroPython
Half day workshop (regular)
en
Following the talk about Aleph.im in the previous days, we will create a device that pushes its data to a decentralized and verifiable (signed data) network.
Creating devices with Python is now possible for a few years (I even did a workshop about this two years ago here), but what if you want to guarantee your data can't be tampered, and don't want to trust a server either?
You will need the power of decentralized applications, elliptic curve cryptography and smart contracts. Wow, that sounds hard, plus it will cost money (tokens), bwah.
Nope, not with Aleph.im: it's quite simple and we will do it together!
We will setup micropython on small devices and start sending a program to the devices sending sensor data.
The interesting part here is that we won't use standard storage servers but api servers of a decentralized cloud. The aleph.in network will take care of storage and processing of our data, giving us and others guarantees of immutability (hashes stored on a few blockchains).
No pre-requisites here, beside knowing python.
Moshe Malawach
2019-06-05T13:00:00+00:00
13:00
03:30
Room 2
workshops-168-wrapping-c-code-and-running-it-in-python
https://cfp.pycon.org.il/workshops/talk/3GB9DL/
false
Wrapping C code and running it in Python
Half day workshop (regular)
en
Python is known for its ability to interoperate with other languages. We will learn how to call C from Python using CFFI, Ctypes, Cython, and others
The workshop is based on the jupyter notebook avaiable [here](https://github.com/mattip/c_from_python). You will want to make sure you have an appropriate python3 environment ready, including cppyy which can be installed via pip.
Starting from a simple pure-python program to produce a Mandlebrot fractal image, we will learn how to:
- Benchmark and profile python performance
- Write the time-critical code in C
- Call the c code from Python using [CFFI](https://cffi.readthedocs.io/en/latest/), [Ctypes](https://docs.python.org/3.6/library/ctypes.html), [Cython](https://cython.readthedocs.io/en/latest/), and if time allows [CPPYY](https://cppyy.readthedocs.io/en/latest/) and [PyBind11](https://pybind11.readthedocs.io/en/master/).
- Compare and contrast the methods: ease of use, maintainability, speed and popularity
At the end we will discuss other solutions for making the pure-python version fast.
Matti Picus
2019-06-05T09:20:00+00:00
09:20
03:30
Pydata
workshops-87-network-science-game-of-thrones-and-python
https://cfp.pycon.org.il/workshops/talk/PEXT8J/
false
Network Science, Game of Thrones and Python
Half day workshop (regular)
en
Have you ever wondered about how those data scientists at Facebook and LinkedIn make friend recommendations? In this tutorial we'll work with networks using Python, and we will look at various real world applications of network science.
This tutorial will introduce the basics of network theory and working with graphs/networks using python and the NetworkX package. This will be a hands on tutorial and will require writing a lot of code snippets. The participants should be comfortable with basic python (loops, dictionaries, lists) and some(minimal) experience with working inside a jupyter notebook.
The tutorial will follow the give outline:
## Part 1: Introduction (30 min)
- Networks of all kinds: biological, transportation.
- Representation of networks, NetworkX data structures
- Basic quick-and-dirty visualizations
## Part 2: Hubs and Paths (40 min)
- Finding important nodes; applications
- Pathfinding algorithms and their applications
- Hands-on: implementing path-finding algorithms
- Visualize degree and betweenness centrality distributions.
## Part 3: Game of Thrones network (1 hour)
- Construct the Game of Thrones co-character network
- Analyze the network to find important characters and communities in the network.
## Part 4: US Airport Network (1 hour)
- Construct the US Airport Network using data from the last 25 years
- Analyze the temporal evolution of importance of airports in the network
- Optimizing the network
## Part 5: Advanced Network Science Concepts (20 mins)
- Quick introduction to machine learning on networks
- Parallel ideas between linear algebra and consensus in networks
By the end of the tutorial everyone should be comfortable with hacking on the NetworkX API, modelling data as networks and analysis on networks using python.
The tutorial and the datasets are available on GitHub at: https://github.com/mriduls/pydata-networkx
Mridul Seth
2019-06-05T13:00:00+00:00
13:00
03:30
Pydata
workshops-170-named-entity-recognition-with-deep-learning
https://cfp.pycon.org.il/workshops/talk/TKPNWB/
false
Named entity recognition with deep learning
Half day workshop (regular)
en
Named-Entity-recog and document-classification are by far the most common NLP tasks.
This workshop would focus on the named-entity-recognition (NER) with deep learning methods.
Natural language processing is an umbrella term for several tasks, common tasks include document-classification, machine translation, and named-entity-recognition.
Deep learning methods had revolutionized the NLP field, breaking state-of-the-art benchmarks in all of these fields.
This workshop would focus on the named-entity-recognition (NER) with deep learning methods.
The workshop is hands-on, meaning that participants are required to bring their own laptop with all the requirements installed.
Python proficiency is assumed, and machine-learning background is a big plus.
Uri Goren