minhmeoke

https://www.hummingbirdnetworks.com/articles/what-is-the-dis...

https://en.wikipedia.org/wiki/IEEE_802.11#Protocol

https://publications.fifa.com/de/football-stadiums-guideline...

Some of these are slightly older devices dating from around 2020, but the sizes should generally still be approximately the same in 2025.

Router/Access point: Mobile operating systems like WebOS, Android, and iOS have had hotspot capabilites built-in since around around 2010 (Mobile Hotspot on Palm Pre and Pixi Plus in 2010 [1], Wifi Tethering in Android 2.2 Froyo in 2010 [2], and Personal Hotspot in iOS 4.3 for iPhone 4 and 3GS in 2011 [3]). Today you can configure your phone to become a personal Wifi router with one button press [4], [5].

[1] https://www.cnn.com/2010/TECH/01/07/ces.palm.pre.plus.pixi/i...

https://web.archive.org/web/20101125023042/http://articles.c...

https://archive.is/UD1Dm

[2] https://www.wired.com/2010/05/android-22-froyo-features-usb-...

https://web.archive.org/web/20140707210122/https://www.wired...

https://archive.is/kjH1N

[3] https://www.engadget.com/2011-03-09-ios-4-3-spotlight-person...

https://web.archive.org/web/20251018061108/https://www.engad...

https://archive.is/QBRod

[4] https://support.google.com/android/answer/9059108?hl=en

[5] https://support.apple.com/guide/iphone/share-your-internet-c...

For a discrete router device, TP-Link TL-WR802N (57 × 57 ×18 mm) [6] and GL-Inet GL-MT300N (58 x 58 x 25mm) [7] are matchbox-sized travel router devices that fit into the palm of your hand, cost less than $30 USD, and consume less than 2.75W (they can be run from a basic 5V, 1A USB connection).

[6] https://www.tp-link.com/us/home-networking/wifi-router/tl-wr...

https://web.archive.org/web/20250724184720/https://www.tp-li...

[7] https://www.gl-inet.com/products/gl-mt300n-v2/

https://web.archive.org/web/20250822045920/https://www.gl-in...

Wifi Client: Wifi capabilities are now built into mobile phone, TV, and many camera chipsets, there is no separate card required. If you want a separate WiFi adapter, you can buy a USB adapter that is about the size of a fingernail or 5 small coins stacked together (eg: 5 US pennies, or 5 Euro 1-cent coins), basically take the metal part of a USB-A male connector and extend or extrude it a bit. This Asus USB-AX56 adapter [8] is 25.5 x 16 x 9mm and supports WiFi 6 (802.11ax) with theoretical speeds up to 9.6 Gbps (actual real-world speeds appear closer to 800 Mbps). Streams in Wifi 6 can be up to 160MHz wide via channel bonding of up to 8 adjacent 20 MHz channels, but in practice this is only feasible in locations with low or no interference. Note that wider channels have a reduced effective range and perform poorly at a distance or through obstructions.

[8] https://www.asus.com/networking-iot-servers/adapters/all-ser...

https://web.archive.org/web/20251018061524/https://www.asus....

https://www.wi-fi.org/wi-fi-macphy

Discrete Wifi cards can still be found in some laptop computers (although many Wifi cards are now soldered down), one of the more recent (introduced around 2013 to 2015) and smaller sizes is M.2 2230 (22mm x 30mm x 2.4mm) which is also the form factor for some M.2 PCI-Express SSDs (solid state storage drives, typically flash devices). These are about the size of a postage stamp, weigh around 2.3 grams, and cost around $20 USD or less.

One example is Intel AX210 [9] which supports Wi-Fi 6E, on 3 bands: 2.4 / 5 / 6GHz in a 2x2 configuration (2 TX transmit and 2 RX receive antennas) at speeds of 2.4 Gbps, and also features Bluetooth 5.3.

[9] https://www.intel.com/content/www/us/en/products/sku/204836/...

A popular previous-generation device is Intel Dual-Band Wireless Adapter AC-7260NGW [10] with good support for GNU/Linux, again with a M.2 2230 (22mm x 30mm x 2.4mm) form-factor approximately the size of a postage stamp, supporting Wifi 5 802.11ac with up to 867 Mbps theoretical bandwidth on dual bands in a 2x2 configuration (2 TX transmit and 2 RX receive radios), and 433 Mbps per stream. Channels can be up to 80MHz wide via channel bonding of 4 adjacent 20 MHz channels.

An alternative, earlier form factor was Half Mini-PCI-Express, for example Intel Dual-Band Wirelss Adapter AC-7260HMW [10] at 26.80 x 30 x 2.4 mm.

[10] https://www.mouser.com/datasheet/2/612/dual-band-wireless-ac...

https://web.archive.org/web/20251018061520/https://www.mouse...

1. Install Android Platform Tools from: https://developer.android.com/tools/releases/platform-tools#... and verify that you can execute the adb tool.

2. Connect the Android device and the computer to the same Wi-Fi network

3. Also connect the Android device to the computer via USB cable (just for this initial setup)

4. Pair the phone with the computer and enable Wireless debugging as described here: https://developer.android.com/tools/adb#connect-to-a-device-...

# Subsequent usage (does not require USB cable):

5. Toggle the Wireless Debugging quick setting toggle to enable adb connections from your computer to your phone

6. Retrieve the Android device's IP address in Settings → About → Status.

7. On the computer command line type: adb connect ip-address-of-device:5555

8. Push the folder to the Android device: adb push /path/to/folder/to/copy/on/computer /sdcard/path/to/destination/on/android/device

    python -m http.server 8000

You can download prebuilt binaries for x86-64 Linux, Windows, or Mac OS (sorry, no prebuilt binaries for Apple Silicon, but they could be added if there is sufficient demand) from https://github.com/akovacs/uploadserver/releases/ or compile from source using a nightly rust toolchain if you prefer.

Compared to cloud services or `python -m http.server 8000`, this is extremely fast since the server is written in rust, it is fairly simple (compiled and stripped binary is typically less than 3MB), it sends everything over local LAN, it seems to handle large files (over 4GB) fairly well, and you only need to install the software on one machine.

For additional details, please see: https://news.ycombinator.com/item?id=39665095

    python -m http.server 8000

You can download prebuilt binaries for x86-64 Linux, Windows 7 or higher, or Mac OS 10.7 Lion or higher (sorry, no prebuilt binaries for Apple Silicon, but they could be added if there is sufficient demand) from https://github.com/akovacs/uploadserver/releases/ or compile from source using a nightly rust toolchain if you prefer.

Start the file server on a desktop machine:

    chmod +x upload_server
    ./upload_server

    # Linux
    hostname -I

    # Mac
    ifconfig

    # Windows
    ipconfig

    curl -X POST --data-binary @file_to_upload.txt http://192.168.1.X:8000/uploaded_file.txt

    curl http://192.168.1.X:8000/uploads/uploaded_file.txt --output downloaded_file.txt

Compared to cloud services or `python -m http.server 8000`, this is extremely fast since the server is written in rust, it is fairly simple (compiled and stripped binary is typically less than 3MB), it sends everything over local LAN, it seems to handle large files (over 4GB) fairly well, and you only need to install the software on one machine.

https://www.unravelled.dev/how-architecture-diagrams-enable-...

https://news.ycombinator.com/item?id=37222855

- Can check the textual description of the diagram into version control and track how it changes over time

- Can easily diff 2 versions of the same diagram

- Adding elements to a large existing diagram using WYSIWYG tools can be tricky (eg: you may have to move or reroute existing elements to make enough space)

Another cool idea is to create multiperspective diagrams with different views for different purposes (eg: code structure, deployment, network architecture, security):

- Clarity. By breaking up diagrams into perspectives, diagram authors can bring much more clarity to a system. Individual concerns can be spread out over many perspectives, allowing each the space it needs without interfering with others.

- Extensibility. Multiperspective diagrams share a model, so creating additional perspectives from an existing diagram is incredibly easy, far easier than starting from scratch each time.

- Maintainability. A corollary to the above, individual perspectives can be modified without affecting the others. Diagrams that are easy to maintain get maintained, while diagrams that aren’t fall out of date quickly. Multiperspective diagrams greatly help in the fight to keep documentation up-to-date.

This is a cool demo: https://app.ilograph.com/demo.ilograph.Stack%2520Overflow%25...

For other textual diagramming tools and ideas, please see this thread: https://news.ycombinator.com/item?id=37222855

Disclaimer: I'm not affiliated with Ilograph, just stumbled onto their blog and I think they have a lot of cool ideas.

A useful filesharing utility that a friend wrote is https://github.com/akovacs/uploadserver - it's basically a nicer version of:

    python -m http.server 8000

Determine your machine's IP address using:

    # Linux
    hostname -I

    # Mac
    ifconfig

    # Windows
    ipconfig

    chmod +x upload_server
    ./upload_server

    curl -X POST --data-binary @file_to_upload.txt http://192.168.1.X:8000/uploaded_file.txt

    curl http://192.168.1.X:8000/uploads/uploaded_file.txt --output downloaded_file.txt

A friend wrote a faster and more sophisticated version of `python -m http.server 8000` in rust which also supports uploads, you can read about here: https://news.ycombinator.com/item?id=37628347

File transfers are performed over the local network, and therefore should be very fast. If you don't have a network connection, you can just enable a Wifi hotspot on your mobile device and transfer the files over that. There is no need to install any software on the mobile device, you can just use a web browser to browse to a directory that you share over the network.

A friend wrote a faster and more sophisticated version of `python -m http.server 8000` in rust which also supports uploads, you can read about here: https://news.ycombinator.com/item?id=37628347 File transfers are over the local network, and therefore should be very fast.

    python -m http.server 8000

A friend wrote a faster and more sophisticated version of `python -m http.server 8000` in rust which also supports uploads, you can read about here: https://news.ycombinator.com/item?id=37628347

A useful utility that a friend wrote is https://github.com/akovacs/uploadserver - it's basically a nicer version of:

    python -m http.server 8000

Start the file server, and then navigate to it using the web browser of your choice on any device (no need for a client application).

    chmod +x upload_server
    ./upload_server

    curl -X POST --data-binary @file_to_upload.txt http://192.168.1.X:8000/uploaded_file.txt

    curl http://192.168.1.X:8000/uploads/uploaded_file.txt --output downloaded_file.txt

    # install rust toolchain
    sudo apt install rustc git
    curl https://sh.rustup.rs -sSf | sh
    rustup install nightly
    rustup default nightly
    git clone https://github.com/akovacs/uploadserver
    cd uploadserver
    cargo run --release

If you have more sophisticated requirements, it seems like Wireshark has the ability to stream and record data in real-time: https://www.csselectronics.com/pages/can-bus-to-usb-wireshar... is an ~$70 adapter which shows up as a serial port

Alternatively, https://canable.io/ with USB port seems to support several open source software packages (there are clones of Canable 2.0 Pro available for ~$17 on AliExpress, but hopefully the official version will come back in stock soon):

- Cangaroo (Windows, Linux): Send/receive standard and FD frames, decode messages from DBC files

- SocketCAN (Linux) Native Linux support using slcand (can record and pass into Wireshark)

- python-can (Windows, Linux, Mac) Easily interface with the CAN bus using your CANable and Python scripts

You can also use SigRok to visualize the CAN frames: https://kentindell.github.io/can2

Disclaimer: I have no affiliation and have not used either of these, just posting them as possible options.

It's basically a nicer version of:

    python -m http.server 8000

It works on Windows, Mac, and Linux, and therefore should probably work on FreeBSD as well if you can install a Rust toolchain:

    pkg install curl
    pkg install git
    pkg install rust
    git clone https://github.com/akovacs/uploadserver
    cd uploadserver
    cargo run --release

    curl -X POST --data-binary @file_to_upload.txt http://localhost:8000/file_to_upload.txt

Alternatively, if you want to stick to ASCII output, https://arthursonzogni.com/Diagon/#Sequence supports several formats (see the dropdown) which can pipe into something like Typogram (https://google.github.io/typograms/) for more beautiful output.

For example, input:

  Renderer -> Browser: BeginNavigation()
  Browser -> Network: URLRequest()
  Browser <- Network: URLResponse()
  Renderer <- Browser: CommitNavigation()
  Renderer -> Browser: DidCommitNavigation()

  .--------.            .-------.     .-------.
  |Renderer|            |Browser|     |Network|
  '--------'            '-------'     '-------'
      |                     |             |    
      |  BeginNavigation()  |             |    
      |-------------------->|             |    
      |                     |             |    
      |                     |URLRequest() |    
      |                     |------------>|    
      |                     |             |    
      |                     |URLResponse()|    
      |                     |<------------|    
      |                     |             |    
      | CommitNavigation()  |             |    
      |<--------------------|             |    
      |                     |             |    
      |DidCommitNavigation()|             |    
      |-------------------->|             |    
  .--------.            .-------.     .-------.
  |Renderer|            |Browser|     |Network|
  '--------'            '-------'     '-------'

One more ASCII-based tool that you could add into your workflow is https://arthursonzogni.com/Diagon/#Sequence which can be used to generate the ASCII that you input into Typogram.

For example, input:

  Renderer -> Browser: BeginNavigation()
  Browser -> Network: URLRequest()
  Browser <- Network: URLResponse()
  Renderer <- Browser: CommitNavigation()
  Renderer -> Browser: DidCommitNavigation()

  .--------.            .-------.     .-------.
  |Renderer|            |Browser|     |Network|
  '--------'            '-------'     '-------'
      |                     |             |    
      |  BeginNavigation()  |             |    
      |-------------------->|             |    
      |                     |             |    
      |                     |URLRequest() |    
      |                     |------------>|    
      |                     |             |    
      |                     |URLResponse()|    
      |                     |<------------|    
      |                     |             |    
      | CommitNavigation()  |             |    
      |<--------------------|             |    
      |                     |             |    
      |DidCommitNavigation()|             |    
      |-------------------->|             |    
  .--------.            .-------.     .-------.
  |Renderer|            |Browser|     |Network|
  '--------'            '-------'     '-------'