Table of Contents

1. local-first

Bootstrap the education of a software developer with Python experience on `local-first`:

- Provide a learning roadmap in org-mode format starting at heading level 3 (*** <header>)
- Include key concepts, technologies, and skills to learn
- Suggest courses, books, tutorials, and projects with links 
- Prioritize and sequence the material logically

The following should provide an initial set of goals: 

We are looking to advance the state of the art to program local-first software, that is, programs that are useful to a single user while offline, but allow sharing and collaboration when connected. Examples topics include:

language constructs that enable offline use
case studies that consider what works well and what is challenging using existing languages
UI techniques that consider connectivity states
users, identities, and trust as language constructs
type systems to track what functionality is available offline
easy to use APIs for (new and existing) efficient data synchronization algorithms
dynamic placement techniques that scale down to a single offline device
Last years keynote talk also suggested nine problem areas we would like to see solutions for, that serve as examples for interesting problems to solve:

Networking: Tech that still works in 40 years?
Schemas: How to allow independent evolution?
Security & Privacy: Whom to trust?
Version Control: How to let users access and manage multiple versions?
Indexing & Queries: How to scale local-first to more than what fits in memory?
Decentralized Search: How to make non-replicated information accessible to everyone?
Portable Compute: How to replicate – distribute – application execution?
Code as (CRDT) Data: How to improve the collaborative coding experience?
Programming Models: How everything fits together, and the core question of this workshop.

1.0.1. Roadmap: Learning Local-First Development

This is a basic roadmap to guide you through understanding and developing local-first applications effectively. Get Familiar with Local-First Concepts

Before adventuring into the development, it is crucial to understand the concept of local-first software.

Some resources to start:

  1. Readings:
  2. Tutorials: Language Constructs and Type Systems

The building blocks of coding local-first software, offline functionalities, type systems for these functions, and user identity management.

Learn about the specific features of programming languages that facilitate the development of local-first applications:

  1. Courses:
  2. Books:
    • "Python for DevOps: Learn Ruthlessly Effective Automation"
  3. Projects:
    • Building a simple offline-capable note-taking application using Python and SQLite
    • Implementing user authentication in a local-first application UI Techniques and Networking

Learn how to craft user interfaces that adapt to different connectivity states and efficient synchronization technologies.

  1. Courses:
  2. Books:
    • "Offline-First Web Development"
  3. Projects:
    • Integrating the React offline UI library into a project
    • Building a local network game using Python socket programming Security, Privacy, and Trust

As local-first applications store more data on the user’s device, it’s essential to understand how to secure this data, manage privacy, and build trust.

  1. Resources suggested: Version Control, Indexing & Queries, Decentralized Search

Master the skills required to manage multiple versions of data and search in the decentralized and local-first context.

  1. Courses:
  2. Books:
    • "Designing the Search Experience: The Information Architecture of Discovery"
  3. Projects:
    • Building a version-control system for a local-first note-taking application
    • Implementing Elasticsearch in a local-first Python application Portable Compute and Code as (CRDT) Data

Understand how to distribute application execution and improve the collaborative coding experience by using code as CRDT data.

  1. Courses:
  2. Projects:
    • Implementing a basic distributed compute in a Python CRDT-based application
    • Building a mini collaborative code editor using Y.js and Python

2. Projects

Bootstrap the education of a software developer with Python experience on `Building a simple offline-capable note-taking application using Python and SQLite`:

- Provide a learning roadmap in org-mode format starting at heading level 3 (*** <header>)
- Include key concepts, technologies, and skills to learn
- Suggest courses, books, tutorials, and projects with links 
- Prioritize and sequence the material logically

Create a tutorial to build that system.

2.0.1. Learning Roadmap for Building a Simple Offline-Capable Note-Taking Application using Python and SQLite Step 1: Review Python Skills

Before diving into the project, it's important to review your Python skills. If you're starting out, consider taking a beginner Python course. Some useful resources include: Step 2: Understand SQLite3 and Its Integration with Python

SQLite is a software library that provides a relational database management system. To dive deep into SQLite3, you'll need to understand the basics of databases, SQLite3 standard commands, and how to integrate it with Python. Step 3: Learn tkinter for Graphical User Interface (GUI)

The tkinter package (“Tk interface”) is the standard Python interface to the Tk GUI toolkit. You would need to understand the basics and how to design simple forms with the package. Step 4: Apply Your Knowledge to Build the Application

Now, with the knowledge you have gathered, it's time to start building the simple offline-capable note-taking application. This project will help consolidate your learning and boost your confidence in Python programming and SQLite. Step 5: Test the Application

Learn how to test your application to find and resolve issues. You can utilize Python's unittest module for this task. Step 6: Review Code and Improve

Lastly, iterate over your code repeating steps 4 and 5 until you have a bug-free application.

2.0.2. Simple Offline-Capable Note Taking Application Tutorial

  1. Step 1: Setting Up

    First, you'll need to create a new Python file and import the necessary modules.

    ```Python import sqlite3 from tkinter import * ```

  2. Step 2: Set up SQLite Database

    Next, connect to SQLite and create a table to store notes.

    ```Python conn = sqlite3.connect('notes.db')

    c = conn.cursor()

    c.execute("""CREATE TABLE notes ( title text, note text )""")

    conn.commit() conn.close() ```

  3. Step 3: Create UI with tkinter

    Create a simple UI for adding and viewing notes.

    ```Python root = Tk()

    titlelabel = Label(root, text='Title') titlelabel.pack() titleentry = Entry(root) titleentry.pack()

    notelabel = Label(root, text='Note') notelabel.pack() notetext = Text(root) notetext.pack()

    def addnote(): conn = sqlite3.connect('notes.db') c = conn.cursor() c.execute("INSERT INTO notes VALUES (:title, :note)", { 'title': titleentry.get(), 'note': notetext.get("1.0", END) }) conn.commit() conn.close()

    addbutton = Button(root, text='Add note', command=addnote) addbutton.pack()

    root.mainloop() ```

    This basic TKinter UI consists of two text entry fields for the note's title and text, and a button to add the note.

  4. Step 4: View Notes

    The final step is adding a function to view existing notes. Add this code to create a new button and function:

    ```Python def viewnotes(): conn = sqlite3.connect('notes.db') c = conn.cursor() c.execute("SELECT *, oid FROM notes") records = c.fetchall()

    printrecords = ''

    for record in records: printrecords += str(record[0]) + " " + "\t" + str(record[1]) + "\n"

    querylabel = Label(root, text=printrecords) querylabel.pack()

    conn.commit() conn.close()

    viewbutton = Button(root, text='View notes', command=viewnotes) viewbutton.pack() ```

    This concludes the basic tutorial of creating an offline-capable note-taking application using Python and SQLite. For full application, you might want to add options to edit and delete notes and add a better user interface. You can also incorporate error handling and further testing for robustness.

Author: Jason Walsh

Created: 2023-10-27 Fri 16:06