I don't mean just vacuum tubes or even electronics at all. Mechanical analog computing is insane when you get down to it. You have special shapes that move against each other and do calculus.

We make these mechanical models as analogs of more complex physical systems. We can turn huge calculations into relatively simple machines. That we can roll two weirdly shaped gears together and get an integral out says to me something very profound about the universe. I find it to be one of the most beautiful concepts in all of the sciences.

What's even more wild is that we can take those mechanical analogs of physical systems and build an electronic analog out of vacuum tubes. That vacuum tubes work at all is just completely insane, but it's some absolutely beautiful physics.

And yes, there are equally beautiful problems that can only be solved in the digital domain, but it just doesn't speak to me in the same way. The closest thing is the bitwise black magic like fast inverse square root from a special constant and some arithmetic. Besides, that's more a property of number systems than it is of digital computation.

I understand how and why digital took over, but I can't help but feel like we lost something profound in abandoning analog.

The tide height is a function of the earth/sun/moon systems. Earth and Moon aren't at a fixed distance from eachother, and neither is the sun, so every day is a unique tide but you can predict the range.

The analog way to do it is to make a gear for each point of data in the system and synchronize all their gears. Then you use them all to rotate one final gear, which will show you the prediction for the time you've chosen.

[1] https://zapatopi.net/kelvin/papers/on_the_age_of_the_suns_he...

[2] https://www.youtube.com/watch?v=IgF3OX8nT0w from about 3 minutes.

Once you really understand how these systems are an analog of a physical problem, everything makes so much more sense

Honestly it seems like a perfect application. Neural networks are analog systems. An analog computer can represent neurons very accurately and the entire network is inherently parallel, for free!

I can't wait to see what comes out of this research

Also, most people don’t know that the word „Analog”, as in „analog circuits” comes from „analogy”.

In today's world, we still build analogs, we just coerce them into strictly numerical, digital models. I don't know if you can call it better or worse, but digital is definitely less magical and wondrous than mechanical analog systems.

Imagine writing a program if every time you wanted to change something you had to cut a new gear, or design a new mechanism, or build a new circuit. Imagine the sheer complexity of debugging a system if instead of inspecting memory, you have to disassemble the machine and inspect the exact rotation of hundreds of gears.

Analog computing truthfully doesn't have enough advantages to outweigh the advantage of digital: you have one truly universal machine that can perform any conceivable computation with nothing but pure information as input. Your application is a bunch of binary information instead of a delicate machine weighing tens to hundreds of pounds.

Analog computing is just too impractical for too little benefit. The extra precision and speed is almost never enough to be worth the exorbitant cost and complexity.

These machines can calculate ballistic trajectories with incredible accuracy, accounting for the relative motion of the ships, wind speed, and even the curvature of the earth. Those calculations are not at all trivial!

https://youtu.be/s1i-dnAH9Y4?si=oHHJGRqnFx-ydQu1

It's a protocol/tool for async file transfer, built for disconnected/intermittent connectivity amongst known parties (trusted friends as p2p), allowing even for sneakernet-based file transfer.

It's started as a modern take on usenet, but it boggles my mind how cool it is:

Want to send a TV Series to your friend? send it via nncp, and it will make it through either via line-based file transfer (when connection allows, pull or push, cronjob, etc), or even via sneakernet if there is "someone going that way".

Comms priority system lets you hi-prio message-checking via expensive network link vs bulk file transfer using trunk lines later.

It even can be configured to run arbitrary commands on message receive, to allow indexing/processing of files (like a ZFS-receive hook, mail/matrix ingestion...)

See all the usecases: http://www.nncpgo.org/Use-cases.html

As with many of these cool techs, I just wish I had a good reason to use it =D

- Tarantool is some sort of in-memory DB with optional persistence

- Red is a programming language that has made the odd syntax decision to use {} for strings and [] to define scopes

- U++ is one of those all-encompasing C++ frameworks like QT

- Lazarus is a Pascal(?) IDE

- And FASM is a toolkit for building assemblers

I'm struggling to find the common thread across these links, apart from the OP probably being an enthusiast of obscure programming languages

http://www.rebol.com/

https://en.wikipedia.org/wiki/REBOL

You can create highly specialized templates in Lua, and there's a RDBMS extension called Cargo that gives you some limited SQL ability too. With these tools you can build basically an entirely custom CMS on top of the base MW software, while retaining everything that's great about MW (easy page history, anyone can start editing including with a WYSIWYG editor, really fine-grained permissions control across user groups, a fantastic API for automated edits).

It doesn't have the range of plugins to external services the way something like Confluence has, but you can host it yourself and have a great platform for documentation.

Personally I would prefer a wiki with git backend. I wrote one [1] but I dont recommend using it.

https://github.com/entropie/oy

[1] Docusaurus:

https://docusaurus.io/

[2] Tinasaurus:

https://github.com/tinacms/tinasaurus

As an administrator, I wish MediaWiki had a built-in updater (bonus points if it could be automated).

I get that by using the container distributions. I just mount My LocalSettings.php and storage volumes in the appropriate places and I get a new version.

And since I run on ZFS and i take a snapshot before updating if something goes wrong I can rollback the snapshot, and go back to when stuff just worked (and retry later).

What I wish more people knew was that you don't need to do those things to get value from Nix. Create project specific dev shells that install the packages (at the correct versions) to work with that project can almost replace 90% of the docs for getting setup to work on a project.

conceptually a game changer for me. In practice it's far from a silver bullet (because every language prefers its own package management so you still have to manage those), but when it works it's quite magical.

Or was the issue that you expected them to be portable? Or use commonly known dynamic library locations?

For example I tried to run pip install yesterday on MemGPT on Nix.

It failed with a C++ error because they use miniconda.

I just created a nix shell with python, pip, etc and ran the pip install command.

Things work fine.

I fell down the Nix rabbit hole, and miniconda was one of the worst things to get working. My first pass used an FHS environment, but eventually I just got the environment.yml file working in micromamba and used that instead. Except micromamba ships it's own linker that I had to override with SHAREDLD, or some random python c++ dependencies wouldn't compile correctly.

I love Nix, but my list of complaints is a mile long. If you want to do anything with opengl in nix, but not on nixos, just give up. NixGl just doesn't really work.

Good luck getting something like Poky (Reference project for Yocto) running in Nix. The only working example puts it in an FHS environment, which uses bubble wrap under the hood. But then because you're in a container with permissions dropped, you can't use a vm. The solution I see in the support forums is roll your own alternative FHS environment based on something else.

/Rant

1) not just as well because docker is repeatable, not reproducible

2) not if you need GPU acceleration which is a headache in docker, but not Nix shells

> Additionally docker-compose allows you to manage a constellation of environments simultaneously. This is nowhere near as straightforward with nix.

- devenv.sh - arion - https://flakular.in/intro

> Most people won't know what to do with a shell.nix

The same was once true for Dockerfile

Not sure what you're saying here but most likely you're referring to some obscure pedantic difference. Effectively speaking docker and nix shell achieve similar objectives.

>2) not if you need GPU acceleration which is a headache in docker, but not Nix shells

This is true. But this is the only clear benefit I see.

>- devenv.sh - arion - https://flakular.in/intro

right. So? I said nowhere near as straightforward. This isn't straightforward. It's an obscure solution.

>The same was once true for Dockerfile

False. DockerFiles are much more intuitive because it's just a declarative config. With Nix shell it's mostly people who like haskell or OCaml who are into that style of syntax. I like it but clearly that syntax has not caught on for years and years and years. Quite likely Nix will never catch on to that level too.

It is harder to write on average atm, but it's very much worth it to me when it comes to sharing code for development. Also, LLMs help quite a bit when writing nix.

Additionally nix uses shell hacks to get everything working. Docker uses an os primitive DESIGNED for this very use case.

And additionally, because docker uses os primitives you can use docker-compose to manage multiple processes on multiple different environments simultaneously. Something that's much harder to do with nix shell.

Also, one man's "DESIGNED" is another man's hacks. I don't see anything wrong with how nix works. Potato/potato, I guess.

I think I know what you're getting at. nix-shell provides a fast way to get access to that specific shell environment which is a bit more annoying to do with docker. All docker needs to do is provide this interface by default and the only surface level differences between the two techniques is really just the configuration.

>Also, one man's "DESIGNED" is another man's hacks. I don't see anything wrong with how nix works. Potato/potato, I guess.

By any colloquial usage of the term "designed" in this context by any unbiased party, it's obvious Nix is more hacky by any charitable interpretation. NixOS is a layer on top of linux, containers are a linux feature. Thus creating a layer on top of linux to use existing features is the more hacky less elegant solution.

It can actually go in the other direction. Rather then use shell tricks Nix can also use containers under the hood. Overall though the API for docker is superior in terms of editing config files but not switching shells. Additionally the underlying implementation for docker is also superior.

Your main problem is with the API which is just opinionated.

Neither is using virtualenvs for Python packages with native extensions.

a) Unless you literally write everything in one language, you will have to deal with learning, supporting and fixing bugs in N different package/environment managers instead of just one.

b) If you have a project that uses several languages (say, a Python webapp with C++ extensions and frontend templates in Typescript), then Nix is the only solution that will integrate this mess under one umbrella.

b. C++ is the only one that would benefit from nix here because C++ dependencies are usually installed externally. There's no folder with all the external sources in the project. Even so this can be achieved with docker. If you want you can have docker call some other scripting language to install everything if you want "one language" which is essentially what you're doing with nix.

Additionally, as machine-generated content proliferates, I think having services use something like the web of trust concept for membership would be super powerful. The problem is, of course, the terrible UX of cryptographic signatures. But I think there's a lot of opportunity for the group that makes it easy to use.

[0]: https://en.wikipedia.org/wiki/Web_of_trust

Programmability though

https://github.com/schollz/croc

[1]: https://github.com/psanford/wormhole-william

Your book looks great, will check it out.

A Nim talk would be a great fit for the event.

At the time nimble also required me to have NPM to install the the Nim package manager, Nimble. This was not ideal, but looking at [the nimble project install docs](https://github.com/nim-lang/nimble#installation) it seems like it is now package with the language.

Might try dusting it off for some AoC puzzles this year :)

In python, for historical reasons the logging module uses camelCase while most other modules use snake_case, so it isn’t really possible to use the logging module and maintain a consistent style. This is a non-issue in Nim.

E.g. it's something to check but not an error. You can easily set a config to make them an error or ignore them.

http://nim-lang.github.io/Nim/atlas.html

- https://arcan-fe.com/2022/10/15/whipping-up-a-new-shell-lash...

- https://arcan-fe.com/2021/04/12/introducing-pipeworld/

- https://arcan-fe.com/2020/12/03/arcan-versus-xorg-feature-pa...

- https://arcan-fe.com/2021/09/20/arcan-as-operating-system-de...

The latest EU funded 'a12' things are also soooo high concept but not fever dream.

I call it a docs system rather than static site generator because the web is just one of many output targets it supports.

To tap into its full power you need to author in a markup that predates Markdown called reStructuredText (reST). It's very similar to Markdown (MD) so it's never bothered me, but I know some people get very annoyed at the "uncanny valley" between reST and MD. reST has some very powerful yet simple features; it perplexes me that these aren't adopted in other docs systems. For example, to cross-link you just do :ref:`target` where `target` is an ID for a section. At "compile-time" the ref is replaced with the section title text. If you remove that ID then the build fails. Always accurate internal links, in other words.

The extension system really works and there is quite a large ecosystem of extensions on PyPI for common tasks, such as generating a sitemap.

The documentation for Sphinx is ironically not great; not terrible but not great either. I eventually accomplish whatever I need to do but the sub-optimal docs make the research take a bit longer than it probably has to.

I have been a technical writer for 11 years and have used many SSGs over the years. There's no perfect SSG but Sphinx strikes the best balance between the common tradeoffs.

[1] https://www.sphinx-doc.org/en/master/index.html

They are starting to work towards full sphinx functionality in myst markdown, too.

[1] https://myst-parser.readthedocs.io/en/latest/intro.html [1] https://executablebooks.org/en/latest/blog/2023/new-project-...

This podcast episode is worth a listen for anyone interested in these tools and where they're headed: https://talkpython.fm/episodes/show/354/sphinx-myst-and-pyth...

[0] https://www.sphinx-doc.org/en/master/usage/markdown.html

The value prop of Sphinx goes down a lot if you're not using reST because you can't use the extensive catalog of directives, such as the ref directive that I mentioned in my first comment. If you must use Markdown then there's not much difference between Sphinx and all the other Markdown-powered SSGs out there. In other words there's not a compelling reason to use Sphinx if you've got to use Markdown.

From Sphinx's Getting Started page:

> Much of Sphinx’s power comes from the richness of its default plain-text markup format, reStructuredText, along with its significant extensibility capabilities.

https://www.sphinx-doc.org/en/master/usage/quickstart.html#g...

I will have to dig into exactly how much parity we're talking here but if it's very strong parity then I redact my previous statement

Thanks for correcting me!

A notable exception is autodoc (automodule, autoclass, etc.), and any other directives that generate more rST. The current workaround is to use eval-rst:

https://myst-parser.readthedocs.io/en/latest/syntax/code_and...

Some more discussion about that in these issues:

https://github.com/executablebooks/MyST-Parser/issues/163

https://github.com/sphinx-doc/sphinx/issues/8018

What I really hope that exists, is a system where I can reuse the documentation (sections) in other pages, ergonomically

I built that system multiple times to do preprocessing with things like including parts or special linking or referencing images from anyhwere

https://github.com/xmonader/publishingtools/tree/development...

   [text](url)

   `text `_

[1] e.g. https://myst-parser.readthedocs.io/en/v0.13.7/using/syntax.h...

https://hieroglyph.readthedocs.io/en/latest/getting-started....

This meant I could first write a blog post on learning Clojure as a Pythonista[1]; then turn some code samples and tables and images into slides I could present at a public talk on my laptop or desktop[2]; and then finally publish a public notes document that talk attendees could use to easily study or copy-paste code examples[3]. (The notes are the exact same contents of the slides, just rendered in a simple single-page HTML format, with each slide transformed into a section heading, with permalinks/ToC auto-generated.) So, this is generated HTML from a single .rst source[4], all the way down! And, of course, I could version control and render the .rst file powering the slides / notes / etc. in GitHub.

[1]: https://amontalenti.com/2014/11/02/clojonic

[2]: https://amontalenti.com/pub/clojonic/

[3]: https://amontalenti.com/pub/clojonic/notes/

[4]: https://amontalenti.com/pub/clojonic/notes/_sources/index.tx...

Note: the slides in [2] do not play well on mobile. You are meant to use keyboard arrows to advance and tap “t” to switch into tiled mode (aka slide sorter) and “c” to open a presenter console. The slides are powered by a fork of html5slides, which will look familiar if you’ve seen the JS/CSS slide template that Go core developers use in https://go.dev/talks (they generate those with “go present,” a different tool, though).

More recently, I have also used a similar-in-spirit tool called marp (https://marp.app) for generating technical slides from source, but the output and functionality was never quite as good as rST + Sphinx + hieroglyph. The big advantages to marp: Markdown is used as the source, some tooling allows for VSCode preview, and PDF export is fully supported alongside HTML slides.

I have a soft spot for Sphinx, not only because it was responsible for so much great documentation of Python open source libraries (including Python’s own standard library docs at python.org), but also because the first comprehensive technical docs I ever wrote for a successful commercial product were written in Sphinx/rST. And the Sphinx-powered docs stayed that way for a ridiculously long time before being moved to a CMS.

Linux namespaces/cgroups but lighter than Docker.

I use it when I want to limit the memory of a Python script:

``` maxmem="56" #GB

firejail --noprofile --rlimit-as=${maxmem}000000000 python myscript.py ```

I'm not sure I can type out, with trembling fingers, how many dollars have been flushed down the toilet of CCSs by businesses that either had no business experimenting with componentized content, or businesses that didn't have resources for training up staff, or vendors who literally evaporated like morning dew after they'd gotten their initialization fees. So just one single story: one prime aerospace vendor I worked with had started their road to S1000D publishing in 2009. Today - at the end of 2023, and more than twenty million dollars later, with a garbage truck full of sweat and blood - that system has not released a single publication to the end user. Not one.

Previous discussions on HN: https://hn.algolia.com/?q=postgrest

Came here to mention Hasura as well (not sure of it's popularity though) https://hasura.io/graphql/database/postgresql

- https://supabase.com/docs/guides/api#rest-api-overview

- https://supabase.com/docs/guides/getting-started/architectur...

- gron (Greppable JSON): https://github.com/tomnomnom/gron

- MarkDownload (Markdown Web Clipper): https://github.com/deathau/markdownload

- Lean4 links:

-- Theorem proving: https://lean-lang.org/theorem_proving_in_lean4/introduction....

-- Natural Number Game: https://adam.math.hhu.de/#/g/leanprover-community/NNG4

* SSH ForcedCommand. Lots of usecases here, for backups, file storage, git, etc.

* Verilog as a tool for software developers to learn digital electronics. VCS/code/simulation/unit tests are all a lot more familiar and expected for developers.

* Writing tools yourself. There's often decent stable libraries that do 90% of what you want, and the remaining 10% is less effort than dealing with awkward integration with off-the-shelf tools. This relies on having low overhead packaging/deployment, e.g. Nix/Guix/Bazel.

I rely on my home's v6 /56, so I don't have experience with using VMs for this, but I know of a few providers that offer /56 (and above):

* Mythic Beasts and Linode offer a /56 on request. They're not cheap VM providers though.

* https://ifog.ch/en/vps offer /48.

* https://tunnelbroker.net/ offer /48, which can be used via any VPS/home.

https://reddit.com/r/ipv6 for more info.

ESPHome. It's a framework for declaratively building firmware for microcontrollers, based on rules like "This pin is an input with debouncing, when it changes, toggle this".

Contributing to them has probably been the most fun I've had programming in years.

We just need power management, and a C++ implementation of the Native API client. It's so close to being able to replace most of what I'd normally code by hand in Arduino.

https://esphome.io/

RealThunder's fork of FreeCAD: https://github.com/realthunder/FreeCAD

They fix so many issues. Linear patterns can duplicate other linear patterns!

Vorta: It's the best backup technology I've seen. Just an easy guided GUI for Borg, which gives you deduplication. I just wish they let you deduplicate across multiple repositories somehow.

I've been looking for a more convenient way to configure some ESP32-based input devices (similar to macropads). I was interested in QMK, but it doens't support ESP32. So far I've been using MicroPython / CircuitPython, which I generally like, but on multiple occasions I've thought "I wish I could just put this in a config file."

The matrix keypad and key collector components look similar to what I was looking for. Can the key collector be used with other multiplexing methods like shift registers?

You can send keys directly to the key collector from wherever you want, but you'd probably have to configure an individual action for each key, unless there's a feature I'm not seeing.

Maybe you could create a new ShiftRegisterKeypad component?

Lithium Titanate sounds interesting - TIL...

However, lately I've come to like llama.cpp and friends, yes it's not ChatGTP miracle whatever but how often do you /actually/ need that? Despite its tremendous popularity, it still seems like something more people should know about. For me, I've had great fun with running LLMs locally and experiencing their different "flavors" from a more "phenomenological" (what is it like to use them) perspective rather than a technological one.

It’s perfect (so far) for my purposes of an extensible data model.

I’m sure others have augmented applications with “generic” data types (like properties and such). You always walk this fine line that if you fall to far you find you’re writing a database on top of a database.

We’ve also in the past fallen into that hole when building a DB schema that we stumble into what we coined the “absurd normal form” or, also colloquially, the “thing-thing” table that relates everything to everything.

Well, RDF is the thing-thing table, and it just embraces it. And for my project it’s a lot of fun. I have structured types, with specialized forms and screens. But, if desired, the user can jump into adding relations to anything. It’s essentially an RDF authoring environment with templates and custom logic to make entities. And in the end they can always dive into SPARQL to find whatever they want.

It’s not intended to work with zillions of data items, it’s just a desktop tool. I always found it interesting early on that the primary metric for triple stores was how fast they could ingest data, I guess nobody actually queried on anything.

Anyway, it’s fun and freeing to work with.

https://github.com/automatic-ripping-machine/automatic-rippi...

Put a DVD/blu ray in a drive and it automatically determines the title, starts ripping, then pops the disc out when it's done.

There's options for post-ripping transcoding also.

Given that webassembly is a stack language with no GC, i do expect a comeback of concatenative programming some time in the future.

https://www.youtube.com/@siliconvalleyforthinterest1736

I literally made this mistake, creating a wasm interpreter, before I realized it was a terrible runtime bytecode.

It really does give the lightbulb moment. “Don’t try to generate code, that is impossible. Only try to realize the truth… There Is No Code (only data)”

- Data diodes (unidirectional networks) - allow you to monitor a network without allowing external control (or only submit info, never ever exfiltrate it)

- GNU Radio - you can play with your audio ports, and learn instinctively how do deal with all the stuff that used to require DSP chips... then apply that knowledge with a $30 RTL-SDR dongle.

- Lazarus - seconding the above... a really good Pascal GUI IDE. The documentation needs work, but it's pretty good otherwise.

¹) http://wincompose.info/

²) https://en.wikipedia.org/wiki/Compose_key

https://espanso.org/

Fossil: distributed version control and much more in a single executable, from the creators of SQLite: https://fossil-scm.org/

This has accounted for about 90% of everything I've built since 1985.

Pick code generates my side project: https://eddiots.com/1

> Pick was originally implemented as the Generalized Information Retrieval Language System (GIRLS) on an IBM System/360 in 1965 by Don Nelson and Dick Pick [...]

I seriously miss it.

Every once in a while I try to get back into it. Usually it takes the form of trying (and failing) to get a demo/personal version of UniVerse, but lately I've been poking at ScarletDME a little bit. I'd even pay money (not much since this is just hobby stuff, but some) for UniVerse, but even the cost of it seems to be a closely guarded secret.

I HAVE to code in PICK.

"Unless it comes out of your soul like a rocket, unless being still would drive you to madness or suicide or murder, don’t do it." - Charles Burkowski

(Funny, they named the current support company "Rocket".)

Here's the link to the current Universe trial version (free and good until 04/2025. Get it, install it, and make something with it. Please don't let that part of you die.

https://www.rocketsoftware.com/products/rocket-multivalue-ap...

What's the trick to making that form work? It won't accept my @gmail.com address, and I don't really want to use my work email address and potentially mis-represent things. Especially since my work used to use one of Rocket's products.

If you have concerns about doing that, you can just download it from my website at

http://eddiots.com/UVTE_WINDOWS_11.4.1.zip (You may have to cut and paste this link into a new tab. HN doesn't seem to like this.)

If you have any problems or need the UNIX version, just reply here or contact me. email on my profile. Let me know how it goes.

My next phase is to put the PICK-generated svg into codepen and provide links to show how to draw the art with code.

Couple of things I like

- tarantool https://www.tarantool.io/en/

- rebol/red-lang https://www.red-lang.org/

- U++ : https://www.ultimatepp.org/

- lazarus: https://www.lazarus-ide.org/

- fasm: https://flatassembler.net/

- Matrix. It's pretty popular but I see way too many open source projects still saying "join our Discord!" instead of "join us on Matrix!"

Python took 20 years after its introduction to become popular as today, thanks to its more intuitive syntax that was based on ABC.

I really hope after 20 years of its introduction that D will be appreciated and becomes a de-facto language not unlike Python is now. Perhaps even more popular with the advent of connected tiny embedded sensors and machine in the form of IoT are upon us.

- in-process databases (rocksdb, sqlite)

- FoundationDB

- C/C++ and low level programming in general (I wished I learned those instead of js when I was younger)

- State Machines, Actor Model (Orleans Net), Event Sourcing

- Bittorrent for other things than pirating (it looks like it's dying)

- Arduino and similar

- Seastar

- Arrow (ecosystem)

and here for a book to learn it from: https://book.simply-logical.space/src/simply-logical.html

I think it is the closest thing to a "tool for expressing thought" with a proof procedure, which presently exists.

"vopono is a tool to run applications through VPN tunnels via temporary network namespaces. This allows you to run only a handful of applications through different VPNs simultaneously, whilst keeping your main connection as normal.

vopono includes built-in killswitches for both Wireguard and OpenVPN."

the cyber swiss army knife

For publishing documentation / to build the web site: Antora [2].

AsciiDoc has a bit more features compared to Markdown which allows for a richer and more pleasant presentation of the docs.

Antora allows you to have the project documentation in the actual project repositories. It then pulls the docs from all the different repos together to build the site. This also allows you to have the released product versions go in-synch with the docs versions. Antora builds each version of the product as part of one site. The reader can explore different product versions or navigate between pages across versions.

===

[1] https://asciidoc.org/

[2] https://antora.org/

* Graph-relational database

* Queries return objects linked to other objects through properties, not rows

* ... But it's still Postgres under the hood

* Open source

- costs next to nothing to charge

- fast and fun to get around

- never pay for parking

- cheap maintenance

- hauls groceries easily

- good exercise