Discovering First Person View (FPV)​

In '25 my son, Sequoyah Rice, turned me on to FPV quadcopters by showing some videos he recorded from his FPV goggles, featuring his acrobatic and freestyle moves. His skilled flying and practical advice encouraged me launch into the sport and learn some foundational hardware and electronics skills along the way. For which I am thankful! I'll share some of those tips below.

Freestyle, cinematics and many other genres​

First Person View (FPV) is a new phenomenon, sport, and hobby, which has only been accessible for perhaps less than a decade, because of low-cost, miniaturized electronics and sensors. It's totally immersive and exhilarating, with a live stream of video directly into your goggles, and complete remote control over all flight parameters: throttle, yaw, pitch and roll. FPV quads (aka drones) are characterized by high speed, maneuverability, and durability. High voltage lithium polymer rechargeable batteries provide the juice which is required for these high performance craft.

There are several sub-genres and specializations of FPV, both good and nefarious. My interests are mainly in Freestyle, Cruising and Cinematics.

• Cruising/Cinematic: Just exploring for recreation, or mount a 4K HD camera on a FPV quad to make movies or short form content.
• Freestyle: The culture around freestyle and acrobatics is fluid, with pilots constantly inventing and naming new tricks and maneuvers, so the lexicon keeps evolving as the community pushes creative boundaries, much like the culture of skateboarding and surfing.
• Racing: Organizations like Drone Racing League and MultiGP have high speed race courses and tournaments.
• Sports: The Milano-Cortina 2026 Winter Olympics featured FPV quads streaming video in practically every event, which was groundbreaking.
• Long range, high speed, and other specializations.

How to learn​

This is the standard approach. Yes, you really need to learn on a simulator!

1. Buy a radio controller with USB port for use with simulator software, and eventually for use with your future quad. A real radio controller is required to build up your coordination and muscle memory on the sticks/gimbals. I use the RadioMaster TX15. Some planning is required because the radio controller must use the same protocol as your future quad's radio receiver. My kit uses ExpressLRS.
2. Buy a simulator game on Steam. I tried several and prefer LiftOff. It's affordable and has realistic physics.
3. Log at least 20 hours learning to fly in the simulator. There are YouTube tutorial videos by Joshua Bardwell which step-by-step introduce you to flying via the LiftOff simulator.
4. Learn to solder and how to use an electronics multimeter. For a DIY drone build there are 20+ solder joints, some of which are fairly intricate. Some folks were fortunate enough to learn soldering in high school, but that wasn't the case for me. Learn the difference between rosin-core and acid-core solder (I wasted some money, not knowing the difference). Rosin-core is what you want.
5. Learn about the FAA's recreational use exemption and associated educational curricula. A sub-250 grams quadcopter kit is recommended.
6. Do the build then start flying. Details omitted 😅
7. Keep returning to the LiftOff simulator on bad weather days, or to learn new maneuvers in a safe environment.

Don't adore your quad too much. It's just a tool and it will inevitably get lost or destroyed. However, the benefit of going the DIY build route is you can upgrade or replace any of the individual components.

Architecture diagram​

This diagram explains the high level components in my build:

Photo​

DIY FPV Drone Kit - QAV-S 2 Sub-250 Joshua Bardwell SE 3” - Analog

Parts list and software links​

• 🛸 Lumenier DIY FPV Drone Kit - QAV-S 2 Sub-250 Joshua Bardwell SE 3” - Analog with Betaflight
• 📡 iFlight Nano receiver with ExpressLRS
• 🎮 Radiomaster TX15 controller with ExpressLRS
• 🥽 SkyZone SKY04O PRO OLED FPV goggles + omni antenna: VAS Ion Pro, and patch antenna: TrueRC X-AIR MK. II
• 🎬 RunCam Thumb Pro 4K HD camera, post-processed with GyroFlow

My YouTube channel: @westslopeflow​

I create 4K HD FPV videos set to music, and post them to YouTube. Consider adding a Like and Subscribe!

🌎 Thanks for rambling! 👋🏼

Recap: In Part 1, I put on my Data Scientist hat and tried some exploratory data analysis using Wyvern's hyperspectral imagery program. The Jupyter notebook produced in Part 1 was a quick study and does not represent production quality Python, routines, or algorithms.

Moving right along!

Why use a data orchestrator like Dagster?​

Dagster is a data orchestrator built for data engineers, with integrated lineage, observability, a declarative programming model, and best-in-class testability.

As a data engineer and software developer I've worked on many data pipelines, helped scientists deploy their code, and produced data products in collaboration with scientists and business stakeholders across tech startups, government agencies, and non-profit organizations.

There is an anti-pattern which to be honest seems to be the default and the status-quo. I've perpetuated this problem, OK let's just call it a mistake. My colleagues have made this mistake too. It usually plays out like:

• 💡 We need to create some kind of data pipeline, workflow, or extract-transform-load (ETL), and we need it as soon as possible! (Let's call it a "pipeline" for this post.)
• 🐍 We already know a programming language, like Python, Bash, or TypeScript.
• 🚧 We start coding the pipeline in our favorite language, using tried and true procedural and object-oriented coding techniques like:
  • For Loops
  • If-Else Clauses
  • Classes and instances with state
  • Exception Handling
• 🔥 Yeah! Making progress immediately, so we should have something prototyped within a few days, then it should be slam dunk to get it ready for production!
• ⏳ Much time passes.
• 🪳 We now have a brittle, incomplete, hard to maintain, bad approximation, of a data orchestration tool!

In the following two sections, I pulled some insightful quotes from some other engineers about data pipelines:

Opaque and fragile pipelines​

Quoting Brian Davis of Earthmover.io in TensorOps: Scientific Data Doesn’t Have to Hurt:

Every dataset in the status quo is the sum of all its pipeline’s constituent steps. The serial nature of this arrangement has serious implications:

• Did you discover a data error introduced upstream that needs cleaning or correction? Regenerate the whole dataset.
• Do you need to tweak the calculation for a derived quantity? Regenerate the whole dataset.
• Do you want to inline a new variable upstream to improve your model? Regenerate the whole dataset.
• Does your customer want a subtly different deliverable? Rewrite the whole pipeline... then regenerate the whole dataset.

In short, every iterative change anywhere within a pipeline incurs the cost of a wholesale re-run. And this means that, once you’ve moved past the prototyping phase, development slows to a crawl as the value of any incremental improvements must be weighed against the cost of re-running the whole pipeline. All that extra compute time. All that extra storage cost. It’s too expensive, in time and resources and — most importantly — opportunity.

Perks of having an orchestrator in your data eng. toolkit​

Quoting Matt Palmer in a Technical Guide published by O'Reilly and Databricks:

Here’s a breakdown of the perks that come with having an orchestrator in your data engineering toolkit:

• Workflow management: Orchestrators assist in defining, scheduling, and managing workflows efficiently, ensuring tasks are executed in the right order by managing dependencies.
• Automation: As engineers, we should be automating as much as possible (or feasible). Orchestrators can be used to automate routine, repetitive, and even complex tasks, saving time and ensuring tasks run as scheduled without manual intervention.
• Error handling and recovery: Orchestrators often come with built-in error handling and recovery mechanisms. They can retry a failed task, notify the team, or trigger other tasks to fix the issue.
• Monitoring and alerting: Monitoring workflows and receiving alerts for failures or delays are crucial for maintaining reliable data pipelines. Orchestrators provide these capabilities.
• Resource optimization: By managing when and where tasks run, orchestrators help optimize resource use, which is crucial in environments with limited or costly resources.
• Observability and debugging: Orchestrators provide a visual representation of workflows, log management, and other debugging tools, which is invaluable for troubleshooting and optimizing workflows.
• Compliance and auditing: Orchestrators maintain an audit trail of all tasks, which is crucial for compliance with data governance and other regulatory requirements.

Pros and Cons of Jupyter Notebooks​

The pipeline developed in Part 1 was purely exploratory data analysis (EDA) and that analysis was delivered as a Jupyter Notebook. Notebooks are widely used in Data Science for prototyping ideas as well as sharing technical documentation with interactive scripts, in languages such as Python, Julia, or Mojo.

Notebooks are a powerful tool for communication and sharing. For example Jeremy Howard's FastAI Book, Deep Learning for Coders with Fastai and PyTorch: AI Applications Without a PhD is completely written and published with Jupyter notebooks.

There are definitely some gotchas though:

• Global variables (state)
• Out of order cell execution
• Lack of code quality tools like type checking, linting, formatting, security scanning etc.

Port the data pipeline to Dagster​

What's a DAG?​

The "Dag" in Dagster stands for Directed Acyclic Graph, which is a useful concept to be aware of. Dagster's framework enables a modular, declarative approach to data engineering, making it easier to manage dependencies, monitor execution, and ensure data quality.

Scaffold a new Dagster project​

Following the Dagster quickstart, first, we'll install the projects dependencies per the Dagster docs, including the fantastic uv package manager for Python:

# macOS and Linux installation of uv package manager
$ curl -LsSf https://astral.sh/uv/install.sh | sh

# Use uv to create a new dagster project named "pipeline" using create-dagster.
# Respond y to the prompt to run uv sync after scaffolding.

$ uvx create-dagster@latest project hab-detection-wyvern-hsi-dag
...

# It created a scaffold of a project, including a Python venv and README.

$ tree -a hab-detection-wyvern-hsi-dag/
hab-detection-wyvern-hsi-dag/
├── .gitignore
├── .venv/...
├── pyproject.toml
├── README.md
├── src
│   └── hab_detection_wyvern_hsi_dag
│       ├── __init__.py
│      ├── definitions.py
│      └── defs
│          └── __init__.py
├── tests
│  └── __init__.py
└── uv.lock

# Add rest of python dependencies, copied from the Jupyter notebook
$ uv add rasterio shapely geopandas numpy
...

# Add new dependency for dynamically querying the Wyvern STAC:
$ uv add pystac-client
...

# Couple of housekeeping details, this makes materialized assets
# persistent across runs of the dev server
mkdir -p  ~/.dagster
export DAGSTER_HOME=~/.dagster

Now a Dagster pipeline is created, Python dependencies are installed, and we're ready to code!

Scaffold an assets file​

This is simply step 2 of the Dagster Quickstart:

$ dg scaffold defs dagster.asset assets.py
...

The following steps of the Quickstart are

3. Add data
4. Define the asset
5. Run the pipeline
6. Verify the results

Here we'll diverge from the Quickstart, because this pipeline will fetch data from Wyvern's STAC catalog, and derive other downstream data from there. There will be corresponding assets in each node of the pipeline.

Declarative workflows are the best​

In Dagster you express declaratively what the inputs and outputs are for each node in the DAG. Concerns like control flow, logging, serialization, etc. are handled by the orchestrator. Here is one node from this pipeline, illustrating the declarative, Pythonic syntax.

@dg.asset
def green_r550_raster(fetch_stac_item: Item) -> tuple[np.ndarray, dict[str, Any]]:
    """
    Read band from cloud object storage (Green 550nm for NDWI and RGB preview).
    Returns tuple of (Numpy ndarray, raster metadata).
    """
    cog_asset = fetch_stac_item.assets[COG_ASSET_KEY]

    with rio.open(cog_asset.href) as src:
        band_green_r550 = src.descriptions.index("Band_550")
        nodata_val = src.nodatavals[band_green_r550]  # 0-based index
        green_r550 = src.read(band_green_r550 + 1)  # read() uses 1-based index
        meta = src.meta.copy()

    green_r550[green_r550 == nodata_val] = np.nan
    meta["count"] = 1
    return (green_r550, meta)

Using this declarative Python syntax, I added assets for each of the pipeline nodes from Part 1 (see Concept of a production pipeline). Even at this early stage, Dagster can wire up the whole pipeline and visualize it, as shown below:

# validate pipeline config
dg check defs

# launch development server on localhost:3000
dg dev

Implement all the asset nodes​

The DAG implementation at this stage involves copying Python code from the Jupyter Notebook cells, and then passing data between the asset nodes. Dagster has about a dozen built-in I/O managers to choose from, but for this introduction, we'll just use the default FilesystemIOManager.

Discovering parallelism naturally​

The process of creating the pipeline and passing data between the assets naturally decomposes the problem. For example, in the Part 1 Jupyter notebook, there was one cell which - serially - fetched 6 raster bands from object storage.

with rio.open(tampico_mx_url) as src:

    # Blue 464nm for RGB preview
    band_blue_r464 = src.descriptions.index("Band_464")
    blue_r464 = src.read(band_blue_r464 + 1)

    # Green 550nm for NDWI and RGB preview
    band_green_r550 = src.descriptions.index("Band_550")
    green_r550 = src.read(band_green_r550 + 1)

    # Red 650nm for RGB preview
    band_red_r650 = src.descriptions.index("Band_650")
    red_r650 = src.read(band_red_r650 + 1)

    # Dark Red 669nm for NDCI
    band_red_r669 = src.descriptions.index("Band_669")
    red_r669 = src.read(band_red_r669 + 1)

    # Red Edge 712nm for NDCI
    band_red_edge_r712 = src.descriptions.index("Band_712")
    red_edge_r712 = src.read(band_red_edge_r712 + 1)

    # NIR 849nm for NDWI
    band_nir_r849 = src.descriptions.index("Band_849")
    nir_r849 = src.read(band_nir_r849 + 1)
    ...

Certainly the above code cell could have been optimized to use async or multiprocessing Python code, but that's extra coding, and an optimization that was not really intended in the exploratory data analysis.

It turns out to be obvious how parallelize that using Dagster assets. As a bonus, the control flow and parallelism comes for free from the data orchestrator.

Here is a visualization of the pipeline from the Dagster development server. The six raw bands are modeled as separate Dagster assets, and therefore are materialized (generated) in parallel.

Visualization of DAG 🎨​

[The final DAG in Lineage view in Dagster]

Python debugger, fix-and-continue, work avoidance 🎉​

Because Dagster is both a CLI tool, a web app, and a Python module, it delivers a great development experience. Some aspects which I found beneficial:

• Edit pipeline code, while assets are being materialized! (multitasking)
• Fix errors and then resume processing, right where the pipeline left off (work avoidance)
• Python debugger (F5 debugging with VSCode)

Example launch.json for VSCode

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Dagster Dev Server (Debug)",
            "type": "debugpy",
            "request": "launch",
            "module": "dagster",
            "args": ["dev"],
            "justMyCode": true,
            "console": "integratedTerminal",
            "cwd": "${workspaceFolder}",
             "env": {
                "DAGSTER_HOME": "~/.dagster"
            }
        }
    ]
}

Ecosystem of data orchestrator tools​

I hope you enjoyed this quick intro to Dagster, which barely scratched the surface of it's capabilities! The greater ecosystem of data orchestrator tools is rich, here is just a small cross section.

• Airflow "Apache Airflow® is a platform created by the community to programmatically author, schedule and monitor workflows."
• Argo Workflows is "an open source container-native workflow engine for orchestrating parallel jobs on Kubernetes."
• AWS Batch
• AWS Glue ETL and Workflows
• AWS Step Functions
• Dask "a Python library for parallel and distributed computing."
• Dbt "turns data work into a shared, scalable practice by bringing the best of software engineering to the analytics workflow."
• Make: that's right, Make has been running software builds, DAGs, and data pipelines in Unix and Linux systems since the 1970's!

Links to source code at NBviewer and GitHub​

This walkthrough blog post was just a high level view. The GitHub repository has the pipeline source code, and Jupyter notebook.

• Dagster pipeline source code at GitHub
• Notebook at NBviewer.org
• Notebook at GitHub

🌎 Thanks for rambling! 👋🏼

Part 1 of 2​

Data Engineering is a Software Engineering discipline, and one of the things data engineers do is help scientists get their code into production, make it reproducible, and make it fast.

1. In this post, I put on my Data Scientist hat and try some exploratory data analysis (EDA) using: Python, RasterIO, NumPy, Shapely, GeoPandas, MatplotLib, Ipyleaflet, and Jupyter.
2. In Part 2, I wear my Data Engineer hat and port the Python code from the notebook environment into Dagster, a production-grade data orchestrator.

Harmful Algal Bloom (HAB) in the news​

The Guardian recently published this article with related facts, photos and interviews:

As the Earth heats up, the amount of algae in our waterways is rapidly increasing, transforming the colour of lakes and killing entire ecosystems. source: Patrick Greenfield, The Guardian, 2025-06-10

Summary and interactive map​

First try out this interactive map: Zoom in, pan, and switch the raster layers on and off. Each layer was produced in the linked Python notebook, and introduced below.

Apologies because the blog post title was slightly misleading. I am not detecting Harmful Algal Blooms (HAB), rather calculating Normalized Difference Chlorophyll Index (NDCI). Chlorophyll-a is widely used as a representative indicator for algae in water. It's the primary photosynthetic pigment found in almost all photosynthetic organisms, including algae.

There are related indexes which could be explored in the same manner, such as Blue-Green Algae Index (BGI), Floating Algae Index (FAI), and others. For further reading, Wyvern lists many indices and formulas in their Knowledge Center.

The normalized difference indices presented here use conventional GIS raster analysis based on this elegant and intuitive principle. Different materials on Earth's surface (water, vegetation, soil, etc.) reflect and absorb electromagnetic radiation differently across various wavelengths. By calculating the difference between reflectance values in two carefully selected spectral bands, then normalizing this difference, we can highlight specific features while minimizing other factors like atmospheric or illumination conditions.

The specific indices leveraged in this notebook are:

1. Normalized Difference Water Index (NDWI): this index is leveraged to create a water mask, which is used later in the pipeline.
2. Normalized Difference Chlorophyll Index (NDCI): is a simple alternative for detecting chlorophyll-a in water bodies.

The full Python notebook is linked below and can be previewed in NBviewer (recommended) or GitHub.

Wyvern's hyperspectral imagery (HSI)​

Wyvern Space's hyperspectral imagery (HSI) has Visible and Near-Infrared (VNIR) sensors, with 5 meter spatial resolution, and between 23 and 32 hyperspectral bands. Leveraging it's narrow Full Width at Half Maximum (FWHM) allows the sensor to distinguish between many different wavelengths of light.

Open Data Program​

It's excellent that Wyvern has embraced open standards by publishing with flexible licensing and a Spatio-Temporal Asset Catalog (STAC). To access Wyvern's Open Data Program, just browse to https://wyvern.space → Access Open Data.

Walkthrough of notebook​

Find a scene in Wyvern's catalog​

PySTAC client and various other tools and SDKs can be used to search for and download images and metadata from a STAC catalog. However, for this exploratory data analysis it was convenient to browse the web interface (STAC Browser) and select an interesting scene.

Here I selected a scene from December 2024 of near Tampico, MX. It's a humid-subtropical region with both ocean and freshwater features, which seems like a good starting point for Harmful Algal Bloom (HAB) detection.

Visualize Scene Preview PNG from Wyvern​

Wyvern provides an overview image of the satellite scene in PNG format, which they rendered from the peak Red, Green, and Blue bands selected from the 32 bands in the source image. Some observations:

• There is no visible cloud coverage or fog. It is interesting to compare with the provided QA cloud/clear mask rasters below.
• Preview PNG image is not geo-referenced because PNG format does not (at least not directly) support that.
• Preview PNG image does not appear particularly vibrant.

(Wyvern's provided preview PNG. Download full-sized image ~13MB)

The source scene image is in Cloud Optimized Geotiff (COG) format and for the reasons listed above, I decided to create a new preview image in Geotiff format in this pipeline.

⚠️ Architectural decision: surface level reflectance processing​

I will not apply surface level reflectance processing in this pipeline. There are many options but they all require fine tuning and effort. Some examples are: ATCOR, 6S, iCOR, ACOLITE, SPy, HypPy, and ENVI. It is acknowledged this is a shortcut, and for correctness or production usage, this pipeline should use Level 2A:

Level 2A: Image data which has been atmospherically compensated/corrected to bottom-of-atmosphere (BOA) surface reflectance and orthorectified with digital elevation model (DEM) terrain correction. Wyvern Knowledge Center

Visualize QA rasters for cloud/clear mask​

Wyvern provides cloud and clear mask rasters. There appears to be something wrong in this scene's cloud mask because there is no detectable cloud coverage or fog or haze in the visual preview rasters, but there are clouds (1 value) on the cloud mask raster.

(in-notebook raster visualization)

⚠️ Architectural decision: no cloud mask​

I will not use the clear/cloud mask layers for this pipeline. They don't seem accurate, or I cannot interpret the masks. When closely inspecting the preview image above, it basically appears to be a cloud free scene.

New preview image in Geotiff format​

Moving right along. The Python notebook has all the details, but here is the next visual:

(in-notebook visualization of the new preview image Geotiff, RGB, web-ready).

This Geotiff meets the key requirements:

• Geo-referenced
• Vibrant in appearance

Also note this preview image is the satellite base-map which is loaded into the interactive map viewer above.

Normalized Difference Water Index (NDWI)​

Formula​

Where:

• Green = Band 9 (550 nm)
• NIR = Band 30 (849 nm)

Range and interpretation​

The range is [-1, 1] and interpretation is 1 = water and -1 = no water. Values closer to 1 indicate high probability of water, while values closer to -1 indicate non-water features like vegetation or dry soil. In typical applications:

• Values > 0.3: Usually indicate water bodies
• Values between 0 and 0.3: May indicate wet soil or mixed pixels
• Values < 0: Usually indicate vegetation or dry soil

Make water mask raster from NDWI​

These images are copied from the notebook to visualize the pipeline for producing a water mask from NDWI.

(in-notebook visualizations of rasters)

(screen capture of in-notebook polygonized water mask in GeoJSON vector format)

(example of possible water on building roofs? pooled rainwater?)

Normalized Difference Chlorophyll Index (NDCI)​

Formula​

Where

• RedEdge = Band 21 (712 nm)
• Red = Band 17 (669 nm)

Range and interpretation​

The range is [-1, 1] and the interpretation is:

• Higher positive values indicate higher chlorophyll-a concentration
• Values near zero suggest low chlorophyll-a levels
• Typical range is approximately -0.1 to +0.3 for most inland waters

Make NDCI rasters​

These images are copied from the notebook to visualize the pipeline for calculating NDCI and creating the NDCI rasters.

• Higher positive values indicate higher chlorophyll-a concentration
• Values near zero suggest low chlorophyll-a levels
• Typical range is approximately -0.1 to +0.3 for most inland waters

Also note this NDCI raster is a layer which is loaded into the interactive map viewer above.

Concept of a production pipeline​

The linked Python notebook demonstrates a proof-of-concept, and it makes the following data products:

visual preview rasters

• wyvern_dragonette-003_20241229T165203_12324bcb-L1B-viz.geotiff
• wyvern_dragonette-003_20241229T165203_12324bcb-L1B-viz-epsg-3857.geotiff

NDWI-based water mask: analysis-ready, web-ready raster and vector

• wyvern_dragonette-003_20241229T165203_12324bcb-water-mask.geotiff
• wyvern_dragonette-003_20241229T165203_12324bcb-water-mask-viz.geotiff
• wyvern_dragonette-003_20241229T165203_12324bcb-water-mask-viz-epsg-3857.geotiff
• wyvern_dragonette-003_20241229T165203_12324bcb-water-mask.geojson

NDCI: analysis-ready and web-ready raster

• wyvern_dragonette-003_20241229T165203_12324bcb-NDCI.geotiff
• wyvern_dragonette-003_20241229T165203_12324bcb-NDCI-viz.geotiff
• wyvern_dragonette-003_20241229T165203_12324bcb-NDCI-viz-web-epsg-3857.geotiff

What would this notebook look like in terms of a production pipeline? Here is a first diagram of a pipeline, which it is also useful to know, is a Directed Acyclic Graph (DAG). In Part 2, I wear my Data Engineer hat and port the Python code from the notebook environment into Dagster, a production-grade data orchestrator.

Links to notebook at NBviewer and GitHub​

This walkthrough blog post was just a high level view. The notebook has a lot more explanatory text and Python source code.

• View notebook at NBviewer.org
• View at Github

🌎 Thanks for rambling! 👋🏼

In part one of this series, I shared my story of being a Linux user for 30 years. Now let's dive into some specific, useful GIS related commands.

GDAL​

Geospatial Data Abstraction Library (GDAL) installs literally 30+ different raster utility programs, like gdalinfo, gdalwarp, gdal_translate, gdal_merge, gdal_polygonize and many more.

Do you have a GIS raster which you want to work with or convert? Begin with gdalinfo {filename} to inspect it's bands, CRS, resolution, and other metadata. GDAL supports dozens of raster drivers for just about any raster file format you can think of. Common use cases include:

• reading metadata
• converting formats
• reprojecting
• masking
• merging
• rasterization
• vectorizing / polygonizing
• building overviews
• Virtual Raster Tiles (VRTs): a powerful feature for working with virtual datasets.

GDAL can also read directly from object storage (AWS S3), using it's Virtual File Systems drivers, for example:

$ gdalinfo /vsis3/sentinel-cogs/sentinel-s2-l2a-cogs/46/C/DB/2022/10/S2B_46CDB_20221003_0_L2A/B02.tif
Driver: GTiff/GeoTIFF
Files: /vsis3/sentinel-cogs/sentinel-s2-l2a-cogs/46/C/DB/2022/10/S2B_46CDB_20221003_0_L2A/B02.tif
Size is 10980, 10980
Coordinate System is:
PROJCRS["WGS 84 / UTM zone 46S",
...

OGR​

OGR Simple Features Library (OGR) is included with GDAL, which is why they are often referred to as "GDAL/OGR". OGR installs several vector programs:

• ogrinfo works just like gdalinfo, but for vector data.
• ogr2ogr is indispensable for converting between vector formats as well as searching, filtering and transforming vector datasets.

OGR supports dozens of vector drivers for just about any vector file format imaginable.

PDAL​

Point Data Abstraction Library (PDAL) is very much like GDAL, but PDAL is for translating and manipulating point cloud data, for example Lidar.

pdal --help

Jq​

jq is a command-line JSON processor. Technically it's not a GIS-specific tool, however it is a lightweight and flexible command-line JSON processor. The GeoJSON format is common in GIS applications, especially in web applications with RESTful APIs, and GeoJSON is also the foundation for the SpatioTemporal Asset Catalog (STAC) specification. Typical usage includes:

1. pretty-printing
2. querying and filtering
3. printing feature attributes

jq --help

Rasterio​

Rasterio is a Python library that reads and writes geospatial raster datasets. It's built on top of GDAL and Numpy, and provides a Pythonic interface to GDAL's data model. Rasterio is a powerful tool for reading and writing raster data in Python.

Rasterio also installs a cli program, rio, which is similar in purpose to GDAL's command line programs but rio is simpler, friendlier, and has better support for Cloud Optimized Geotiff (COG). Here is a quick start to install rio:

python -m venv venv/
source venv/bin/activate
pip install rasterio
rio --help

Fiona​

Fiona can read and write real-world data using multi-layered GIS formats, zipped and in-memory virtual file systems, from files on your hard drive or in cloud storage. This project includes Python modules and a command line interface (CLI). Fiona docs

Fiona also installs a cli program, fio. Here is a quick start to install fio:

python -m venv venv/
source venv/bin/activate
pip install fiona
fio --help

DuckDB​

DuckDB is an in-process, analytical, portable database which supports geospatial formats and queries. I don't have experience with it (yet) but Mark Litwintschik recently wrote a blog post about Wyvern's Open Data feed of hyperspectral remote sensing imagery, where he uses duckdb as well as several other Linux cli tools.

duckdb --help

Docker one-liners 🐳​

Install Docker Desktop (Mac, Win) or Docker Engine (Linux) and then you can run lightweight containers, as shown in the following examples:

TiTiler raster tiling​

TiTiler, pronounced tee-tiler (ti is the diminutive version of the french petit which means small), is a set of Python modules that focus on creating FastAPI applications for dynamic tiling. A common use case is on-demand raster tiles from Cloud Optimized Geotiff (COG) hosted in S3 or other object storage.

docker run --name try-titiler \
  --platform=linux/amd64 -p 8000:8000 --rm \
  ghcr.io/developmentseed/titiler:latest \
  uvicorn titiler.application.main:app --host 0.0.0.0 --port 8000 --workers 1

Then browse to http://localhost:8000 to start using TiTiler.

PostgreSQL with PostGIS​

PostGIS extends the capabilities of the PostgreSQL relational database by adding support for storing, indexing, and querying geospatial data. Why fumble around with a download and a GUI installer, when you can just run one docker command! Remember to replace the password string ***** with a new password:

mkdir -p ~/pgdata
docker run --name try-postgis \
  -p 5432:5432 --rm \
  -e POSTGRES_PASSWORD=***** \
  -e PGDATA=/var/lib/postgresql/data/pgdata \
  -v ${HOME}/pgdata:/var/lib/postgresql/data \
  postgis/postgis:17-3.5

Then connect to Postgres using psql, DBeaver, PgAdmin, or any Postgres SDK. The latest version tags for the docker image e.g. postgis:17-3.5 are available on GitHub.

QGIS as raster tile server​

Do you have a QGIS project (.qgz file) with 42 map layers which you worked on for 18 months, and now you have to publish it to the web? 😅 No problem- QGIS Server can serve up raster tiles via open standards like WMTS, WMS, XYZ, TMS, WFS, or WCS.

• XYZ format may be easiest for integration with the Mapbox, OpenLayers, and Leaflet web map packages.
• QGIS Server can be slow, depending on the complexity of your map layers, so you will likely want to setup a caching layer such as Varnish, TileStache, or a cloud CDN.

docker run --name try-qgis-server \
  -p 8080:80 --rm \
  -v /path/to/your/project.qgz:/etc/qgisserver/project.qgz \
  -e QGIS_PROJECT_FILE=/etc/qgisserver/project.qgz \
  qgis/qgis-server:latest

Cloud-Native Geospatial (CNG)​

Check out the Cloud-Optimized Geospatial Formats Guide for more useful recipes, formats, and programs.

🌎 Thanks for rambling! 👋🏼

What is Linux​

Linux has been around since the mid-1990s and has since reached a user-base that spans the globe. Linux is actually everywhere: It's in your phones, your thermostats, in your cars, refrigerators, Roku devices, and televisions. It also runs most of the Internet, all of the world's top 500 supercomputers, and the world's stock exchanges. Source: The Linux Foundation

This is expanded below in Postscript: Linux won the Internet and developer mind-share.

Hello, Tux​

Supposedly Linus Torvalds, the inventor of Linux, was inspired by a different penguin illustration, which appears in this wikipedia article. The Tux mascot later evolved from that and became the official Linux icon and logo shown here. [image attribution: lewing@isc.tamu.edu Larry Ewing and The GIMP, CC0, via Wikimedia Commons]

'94 Linux appears on the scene​

The Unix philosophy​

Linux and Unix are very similar. Unix has been around since the '70s. Unix is fundamentally a programming environment that unifies user and development spaces. It's philosophy centers on creating programs that:

• Perform single tasks effectively
• Work together through pipelines
• Process text streams
• Function as filters (input to output)
• Prioritize portability over efficiency

The system is designed to be literate and self-documenting through:

• Integrated documentation (man pages, help flags)
• Built-in command inspection tools
• Interactive learning features
• Human-readable source code and configuration
• Transparent system structure

This design creates an environment where using the system and developing for it are seamlessly integrated, making Unix highly extensible and learnable.

Circa '94, just out of college, I got really interested in Linux, and wanted to get into programming. I asked my father "What programming language do you think I should I learn?". He had some earlier experience with software projects in the field of ecological and weather modeling. He considered it for long pause, and then said "I think you should learn C!".

Even though I never mastered the C language, it was the right guidance. Knowing a modicum of C means you understand compilers, libraries, static and dynamic linking, cache hierarchy, pointers, storage, I/O, etc. With that foundation you can understand any other programming language or operating system.

I saved my favorite books from this time period mostly as a reminder how much it made an impression on me. Kernighan later wrote "The Go Programming Language" which is one of the best programming books ever.

Linux kernel version 1.x​

Micron Millennia desktop PC​

Also circa '94 I installed Linux on my home computer which was a Micron. Manufactured in Idaho (It came from the factory with a potato sticker on it). I experimented a lot with building the Linux kernel from sources and configuring dual-boot systems. [image attribution: Akbkuku, CC BY 4.0 , via Wikimedia Commons]

'95 Reality Construction Company​

Circa '95 in Albuquerque NM, I had graduated from college the year before, and I was really poor and mostly working in restaurants. My friends Kyle, Spiros, Antonio, and I decided to try creating web pages, first for fun, and then for profit. We got a few customers and had this idea to start a tech company. We called it Reality Construction Company (RCC). We were hosting the pages and web apps at a local Internet service provider (ISP), named Southwest Cyberport (SWCP). We were self-taught developers and designers, and were not very good at automating and scripting things. Most (all?) good developers are self-taught though!

'96 Southwest Cyberport​

SWCP was growing rapidly, because the Internet was just being commercialized and popularized. The owners of SWCP are a nice couple named Jamey and Mark Costlow. They offered me a technical support job for their Internet access, web hosting, email and FTP services business.

SunOS and Solaris​

[image attribution: jonmasters, CC BY-NC-SA 2.0]

As a bonus I got to learn about Unix because the Costlows were also very technical and system administrators. They were running SunOS and Solaris Unix. I guess I was kind of an apprentice sys-admin. At one point early on, there was a folding table with about a dozen of these Sun SPARC aka "pizza boxes". The folding table was sagging from the weight, more than a bit.

I learned about the X-Windows display system and we used early versions of Python, TCL, PHP, Perl, Java, Javascript, MySQL, and Postgres. Customers had access to many of these tools which enabled building of dynamic web pages using CGI and HTML. The web servers were multi-user systems, so learning Unix was mandatory for any kind of databases or interactive web apps.

Tech-Kids​

Mark and Jamey were part of a group which someone named "Tech-Kids". I was de-facto part of it because I worked at SWCP, but I was not anywhere near as smart and cool as most of those folks. They had their own Internet Relay Chat (IRC) channel and I remember going to a house party or two.

Over the next several years many of the group moved to Silicon Valley, and I'm sure they were super successful in the Tech industry there. I stayed in New Mexico- as I was already California escapee.

Linux saves the day​

I think it was Brendan Conoboy who first introduced Linux into the SWCP system. He quickly deployed it as a software firewall to plug some security holes and put the Sun machines behind a NAT. Before long, all the SunOS and Solaris "pizza boxes" had been migrated to Linux servers. Brendan went on to maintain the GCC compiler, and then moved to a long career at Red Hat Linux.

'97 Linux kernel version 2.x​

In these days, multiprocessing (SMP) was added, and the range of supported hardware architectures was broadened. I tried it out on some relatively ancient hardware. Each one of these was like a puzzle to figure out how to load and run the OS and various packages.

Sun SPARCStation SLC​

I installed Linux on this little terminal. These were available for free or cheap. It had a monochrome monitor which was pleasing to the eyes. I got X-Windows running, and could browse the web using Netscape Navigator. In grayscale- so cool. It was quiet too because of being fanless. But so slow. [image attribution: David Rosenthal CC BY-SA 3.0 US]

DEC Alpha​

I also installed Linux on this Digital Equipment Corp (DEC) workstation. Also available free or cheap. [image attribution: The Centre for Computing History]

macOS X, BSD Unix for the masses​

macOS 9 and older had a reputation for instability (crashing, and showing the "bomb" screen), because of it's system architecture.

Circa 2001, macOS X revolutionized all that because it introduced preemptive multitasking, protected memory, and a BSD-Unix based subsystem. Finally an OS with a nice graphical interface, and an actual Unix environment with all the tools and compilers one needs.

The last time I went to a developer conference, there was literally a sea of macOS laptops. Apple really has gained traction with developers as well as creative designers. Of course there is always cross section of hardcore Linux folks to running Lenovo Thinkpads or System 76 laptops. We'll dig into developer mind-share more below.

Linux at National Center for Genome Resources (NCGR)​

When I worked at NCGR it was my first exposure to an on-premises data center with a lot of compute and storage. I learned how to parallelize jobs, and submit batches to a cluster of bare metal Linux servers. Lots of Bash shell scripting, Makefiles, Perl and Python. A single genome sequencer instrument can output terabytes of data per day, so the compute and storage requirements were substantial.

Mike Warren's Linux Top500 "stunt" at Descartes Labs​

I worked at Descartes Labs when Mike Warren, the CTO, used a cluster of cloud VMs to compete in a supercomputing contest. This was a first time ever for a team to place in the list of top 500 supercomputers using cloud resources. Thunder from the Cloud: 40,000 Cores Running in Concert on AWS is an inspiring story about the democratization of computing.

Taking stock: Windows at USDA​

My current role is contractor to the U.S. Department of Agriculture (USDA), Farm Production and Conservation Business Center (FPAC) and Natural Resources Conservation Service (NRCS). I was hired to work on a re-architecture and AWS cloud migration of a legacy application. I was actually very surprised to find that basically the entire system is MS Windows. The status quo for desktop computers is, unsurprisingly, Windows. But the servers, databases, and Extract-Transform-Load (ETL) pipelines are also Windows based. Visual Studio Pro, SQL Server Integration Services (SSIS), and SQL Server Management Studio (SSMS) and Remote desktop are required. Chasing down the required software installations, licenses and elevated privileges for Windows authentication literally takes weeks. Then one is hobbled by GUI-only applications and a very lacking command line experience.

Linux/macOS has indisputably won on Internet servers, web development, as well as scientific computing and High Performance Computing (HPC). So why does it feel like I've teleported back 30 years into a giant corporation? Incredible. How is this even possible? Because that's basically exactly what it is. I was able to more or less sort out the history of how we arrived in this state:

FPAC (Farm Production and Conservation) is a mission area within USDA that includes NRCS (Natural Resources Conservation Service) as one of it's agencies, alongside FSA (Farm Service Agency) and RMA (Risk Management Agency). The Windows infrastructure entrenchment in FPAC largely stems from the 1990s modernization efforts. Key factors:

• FSA's legacy AS/400 systems were migrated to Windows-based solutions
• Large contractors (particularly IBM) implemented Service Center Information Management System (SCIMS) using Microsoft technologies
• County offices standardized on Windows desktops for program delivery
• Custom applications were built on .NET/SQL Server stack
• GIS tools like Toolkit initially developed for Windows platforms

This created a Microsoft-centric ecosystem that persists today, despite NRCS maintaining some Unix/Linux systems for scientific computing and conservation planning tools. [Source: Claude 3.5 Sonnet]

I am advocating for a Docker container (Linux) based development approach, Postgres, and AWS deployment, for the modernization of this particular app.

Postscript​

Linux won the Internet and developer mind-share​

Numbers reflect 2024 estimates across enterprise and public infrastructure. Source: Claude.ai

Percent of Internet infrastructure​

Developer mind-share​

macOS is included in the table because it has a BSD Unix subsystem and command line experience, which is explored in the section macOS X, BSD Unix for the masses.

Next steps​

I am currently working on AWS Certified Solutions Architect (AWS CSA-A) certification, and plan to pursue the Data Engineering track after that.

🌎 Thanks for rambling! 👋🏼

I recently applied for a position with a consulting company, Xentity Corp, and the concept of "servant leadership" was briefly mentioned by an interviewer.

After the interview I wanted to better understand what servant leadership means, so I asked Claude (3.5 Sonnet) for some book recommendations or online materials. I tried to get Claude to narrow down responses to government consulting and data engineering. I went back and forth with Claude. All of the recommendations were OK, but nothing was really jumping out at me for a book to read, or papers to download.

Then it occurred to me this is a LLM so why don't I ask it to summarize the material? This is what LLMs are great at: synthesizing and generating reviews of material in a digestible and understandable way. Here is an excerpt, just the end of conversation:

[Q] Have not been able to find a good book that I am interested in reading. Please summarize servant leadership in the context of government consulting- for a tech position (data engineer).

[A] I understand you haven't found a book that captures your interest. Let me summarize servant leadership in the context of government consulting for a tech position like a data engineer: Servant leadership in government consulting as a data engineer involves:

1. Prioritizing stakeholder needs:
   • Focus on understanding and meeting the needs of government clients and end-users.
   • Actively listen to requirements and pain points before proposing solutions.
2. Empowering team members and clients:
   • Share knowledge and skills to help government staff better understand data processes.
   • Mentor junior team members and client personnel in data engineering practices.
3. Ethical data handling:
   • Prioritize data privacy, security, and responsible use of public information.
   • Advocate for transparent data practices and clear communication of data limitations.
4. Long-term thinking:
   • Design scalable, maintainable data solutions that will serve the government beyond your contract.
   • Consider the long-term impact of data architecture decisions on future government operations.
5. Collaborative approach:
   • Work closely with other departments and stakeholders to ensure data solutions align with broader government goals.
   • Facilitate cross-functional communication to bridge gaps between technical and non-technical teams.
6. Continuous improvement:
   • Regularly seek feedback on data solutions and processes.
   • Stay updated on emerging technologies and best practices to better serve government clients.
7. Accountability and transparency:
   • Take responsibility for project outcomes and be open about challenges or limitations.
   • Provide clear, understandable explanations of complex data concepts to non-technical stakeholders.
8. Public service mindset:
   • Align data engineering efforts with the broader mission of improving government services and citizens' lives.
   • Consider the societal impact of data-driven decisions and advocate for equitable solutions.

In practice, this might involve:

• Developing user-friendly data dashboards for government decision-makers
• Creating efficient data pipelines that respect resource constraints of government systems
• Implementing data governance practices that ensure compliance with public sector regulations
• Conducting workshops to upskill government staff in data literacy and basic data engineering concepts

Would you like me to expand on any specific aspect of this summary?

Overall, this was a really good LLM interaction! It was genuinely helpful, and everything seemed legitimate in the response. In future posts I will share some LLM failure modes that I have seen or learned about. I am both fascinated and biased about LLMs, having studied Linguistic Anthropology as an undergraduate.

🌎 Thanks for rambling! 👋🏼

Average annual precipitation​

Attribution: United States Department of the Interior nepes, Public domain, via Wikimedia Commons

Population density​

I added the blue dotted line to hilite the pattern going from Wisconsin down to Texas.

Attribution: SEDACMaps, The Trustees of Columbia University in the City of New York: CC BY 4.0 , via Wikimedia Commons

Acequias, canals, and ditches in the West​

In the West, human settlements were only possible where water exists and agriculture was possible. Acequias, irrigation ditches and canals are the technology that makes this possible.

An acequia is a community-operated watercourse used in Spain and former Spanish colonies in the Americas for irrigation. Acequias are found in parts of Spain, the Andes, northern Mexico, and the modern-day American Southwest (northern New Mexico and southern Colorado). source: Wikipedia.

Visualize irrigation with the NHD​

Here are some screen captures of the Southwest US and also the Grand Valley in Colorado. The patterns of irrigation development are correlated with the population density map (above).

Southwest US irrigation​

Map data sourced from the National Hydrography Dataset (NHD), U.S. Geological Survey, ©OpenStreetMap contributors

Grand Valley, Colorado irrigation​

Map data sourced from the National Hydrography Dataset (NHD), U.S. Geological Survey, ©OpenStreetMap contributors

Technical approach​

1. Researched the NHD and found download options

2. Downloaded with curl and unzipped the national NHD file

curl -O https://prd-tnm.s3.amazonaws.com/StagedProducts/Hydrography/NHDPlusHR/National/GDB/NHDPlus_H_National_Release_1_GDB.zip
unzip NHDPlus_H_National_Release_1_GDB.zip

Contained in the zip archive is a 99GB geopackage file: NHD_H_National_GPKG.gpkg.

3. Explored the features and attributes in QGIS. The dataset has many layers and feature codes. For this quick exploration, I focused on the layer NHDFlowLine and the feature code 33600:"Canal/Ditch".

4. Used GDAL/OGR to efficiently filter on the fcode attribute, producing a new geopackage file: canal-ditch.gpkg.

ogr2ogr canal-ditch.gpkg NHD_H_National_GPKG.gpkg \
    -sql "SELECT * FROM NHDFlowline WHERE fcode = 33600"

5. In a new QGIS project, add an OpenStreetMap XYZ Tiles layer, and the canal-ditch.gpkg geopackage.

I hope you enjoyed this ramble through a population map, precipitation map, and finally the NHD dataset.

🌎 Thanks for rambling! 👋🏼

Mapstodon.space is an online community dedicated to cartography & geospatial enthusiasts. https://mapstodon.space/about

My GIS certificate program, Penn State '16, included an intensive crash course in Esri ArcGIS. More recently, in my professional experience as a developer, I have used free and open source software like QGIS, PostGIS, GDAL/OGR, Rasterio, and GeoPandas. It's great to see the Esri persepective again. As a bootstrapped company for over 50 years, it invests massively into research and development.

This book is a hybrid of a visually appealing coffee-table type of book, with a gentle intro to the state of the art in GIS and the "geographic approach" as well. It would make a nice gift to friends or family who don't yet understand the appeal of GIS and the richness of geodata.

Check out the book at

• Your local library!
• Esri Press
• Amazon

🌎 Thanks for rambling! 👋🏼

What is Mojo​

Mojo is a new programming language that bridges the gap between research and production by combining Python syntax and ecosystem with systems programming and metaprogramming features. Mojo is still young, but it is designed to become a superset of Python over time. source: Mojo docs

What is pytest​

The pytest framework makes it easy to write small, readable tests, and can scale to support complex functional testing for applications and libraries. source: pytest docs

pytest, meet Mojo​

This package implements a pytest plugin to discover and run Mojo tests, alongside your Python tests. Although pytest does not have any awareness of Mojo source or package structure, pytest is extensible. In summary, plugin.py calls mojo test in a sub-process and parses the outputs and exit codes.

Example test using Mojo standard library​

This simple Mojo module shows testing native Mojo code, and also calling into a Python module for testing vs reference implementation.

# file: example_tests/my_package/test_fibonacci.mojo

from python import Python
from testing import assert_equal
from my_package.fibonacci import fibonacci


def test_fibonacci():
    """
    Test fibonacci 10th number.
    """
    expect = 55
    got = fibonacci(10)
    assert_equal(got, expect)


def test_fibonacci_reference():
    """
    Test mojo fibonacci versus python "reference" implementation.
    """
    py = Python.import_module("my_package.fibonacci")
    for n in range(0, 10):
        expect = py.fibonacci(n)
        got = fibonacci(n)
        assert_equal(got, expect)

pytest runs both the Python tests, and the Mojo tests. Example command line usage:

$ pytest --mojo-include example_src/ example_tests/

================================ test session starts =======================
platform darwin -- Python 3.12.6, pytest-8.3.3, pluggy-1.5.0
rootdir: /Users/guidorice/mojo/mojo-pytest
configfile: pyproject.toml
plugins: mojo-24.5
collected 6 items                                                          

example_tests/my_package/my_test.mojo .                              [ 16%]
example_tests/my_package/test_fibonacci.mojo ..                      [ 50%]
example_tests/my_package/test_fibonacci.py .                         [ 66%]
example_tests/my_package/test_fire.🔥 .                              [ 83%]
example_tests/my_package/test_random_tensor.mojo .                   [100%]

================================ 6 passed in 13.55s =======================

Check it out at the GitHub repo: https://github.com/guidorice/mojo-pytest.

Contributor​

Thanks to Leandro Leites Barrios @lleiets for contributions and suggesting the idea of using the pytest plugin API, instead of just a config script.

Further reading​

• See the GitHub repo https://github.com/guidorice/mojo-pytest for more about mojo-pytest.
• Mojo language manual
• Mojo GitHub repository

🌎 Thanks for rambling! 👋🏼

Figure attribution: QGIS documentation: Fig. 27.53 Black lines represent the bounding boxes of each polygon feature.

What is Mojo​

Mojo is a new programming language that bridges the gap between research and production by combining Python syntax and ecosystem with systems programming and metaprogramming features. Mojo is still young, but it is designed to become a superset of Python over time. source: Mojo docs

Contest submission​

Calculates the spatial envelope, and explores the performance of Python, NumPy, and Mojo. The Mojo final implementation is 20X to 600X faster than Python, and 1.3X to 4X faster than NumPy.

Further reading​

• See the GitHub repo https://github.com/guidorice/modcon23-contest for a more detailed writeup, source code, and more benchmark results.
• Announcement of all the winners in Modverse weekly #11
• Mojo language manual
• Mojo GitHub repository

🌎 Thanks for rambling! 👋🏼

Regrow was the second venture capital backed startup which I worked for, the first being Descartes Labs from '17-'19. They had quite a lot in common, being geospatial tech companies, both in series B or growth phase. Observing some of the common patterns I saw:

Pros​

🤩 Work with more talented engineers and scientists

🚀 Quickly level up skills especially in distributed systems, data engineering and big data

✈️ Build the airplane while flying it. Not really a Pro or a Con, more "it is what it is"

Cons​

🙈 Hiring is going faster than the company ops, culture and institutional knowledge can absorb the new resources

📉 No stability- the market and investors can change their minds so quickly

P.S. I recommend the book Hello Startup by Yevgeniy (Jim) Brikman.

🌎 Thanks for rambling! 👋🏼

// filename map.tsx

import { useRef, useEffect, useState } from "react";

export const MapComponent = () => {
    const mapContainer = useRef(null);
    const map = useRef(null);
    const [mapboxgl, setMapboxgl] = useState(null);

    // effect: react reference to the window mapboxgl object. mapboxgl is loaded in <head>.
    useEffect(() => {
        if (window.mapboxgl) {
            setMapboxgl(window.mapboxgl);
        } else {
            const checkMapboxGL = setInterval(() => {
                if (window.mapboxgl) {
                    setMapboxgl(window.mapboxgl);
                    clearInterval(checkMapboxGL);
                }
            }, 10);
            return () => clearInterval(checkMapboxGL);
        }
    }, []);

    // effect: setup and tear down map component
    useEffect(() => {
        if (map.current || !mapboxgl) return;

        // setup access token
        mapboxgl.accessToken = '*****';

        // create map
        map.current = new mapboxgl.Map({
            container: mapContainer.current,
            projection: 'globe',
            style: 'mapbox://styles/mapbox/standard-satellite',
            center: [-85, 30],  // lon, lat
            zoom: 1.5,
        });
        map.current.on('style.load', () => {
            map.current.setFog({
                color: 'rgb(186, 210, 235)', // Lower atmosphere
                'high-color': 'rgb(36, 92, 223)', // Upper atmosphere
                'horizon-blend': 0.02, // Atmosphere thickness (default 0.2 at low zooms)
                'space-color': 'rgb(11, 11, 25)', // Background color
                'star-intensity': 0.6 // Background star brightness (default 0.35 at low zoooms )
            });
        });
        map.current.addControl(new mapboxgl.NavigationControl());

        return () => {
            if (map.current) {
                map.current.remove();
            }
        }
    }, [mapboxgl]);

    return <div ref={mapContainer} style={{ height: '500px', width: '100%' }}></div>;
};

A globe! Yes, you're very clever. (reference: map projections explained in XKCD #977)

👋🏼 Welcome to Geodata Ramblings

Topics​

• Geodata
• GIS
• Geospatial software
• Deep learning, ML and AI
• Mojo language
• Python language

Tech stack​

• Building this with Docusaurus and it's been really convenient to get started!
• Deployed with Netlify!