ubercow

Have you looked into apps like Scanbot [1]

1: https://scanbot.io/en/index.html

Maybe a better link: https://cloudblogs.microsoft.com/opensource/2019/10/16/annou...

and to the GitHub projects themselves https://openappmodel.io/

https://github.com/oam-dev/spec/ https://github.com/oam-dev/rudr/

A couple of big ones I have are:

Video games, movies, books, tv shows I've watched/played or want to watch/play, what platform they are on, if I've bought them already

Brands and blends of tea I've tried, want to try, tasting notes, preferences for brewing amounts and times

Some are just super fancy spreadsheets like serial numbers for expensive electronics I own and when I purchased them.

Trello along with Airtable are invaluable to keeping my life organized.

Semi-off topic but is there a curated "best of" list for systems papers like this that anyone knows about, from Google or otherwise?

It's funny you mention that, I came here just to post another wonderful remix, "Erlang The Movie II: The Sequel".

https://www.youtube.com/watch?v=rRbY3TMUcgQ

Windows has ReFS. From the looks of it, it has some modern features. But I doubt that’ll ever be readable on a Mac.

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

What's the best introduction out there for someone who's never touched M4 before?

I really like the model of Feedbin[1],

Up front no BS business model of "you give us money, we track your rss feeds"

They are even open source too (MIT) [2].

1: https://feedbin.com/ 2: https://github.com/feedbin/feedbin

On mobile I didn’t even notice the features page hidden behind that hamburger menu.

It's very frustrating having all of these tools only support Windows.

Despite all the wonderful work Microsoft has done with CoreCLR, the "IDE" debugger is still only available under a license that only permits use with Visual Studio and VSCode [1] and mdbg is still nowhere to be found for CoreCLR [2].

1: https://github.com/dotnet/core/issues/505 2: https://github.com/dotnet/coreclr/issues/1145

From what I've gathered, the best you have right now for doing command line debugging is the "SOS" plugin for lldb, which seems to require building the lldb plugin and sometimes even lldb (!!) yourself [3][4].

3: https://github.com/dotnet/coreclr/blob/master/Documentation/...

4: http://blogs.microsoft.co.il/sasha/2017/02/26/analyzing-a-ne...

Not very fun if you're not using Windows.

How are you going to signal nginx what to push?

Are you going to be able to push stuff from your application if using Nginx as a proxy? For example, a dynamic view that includes a css file hosted by nginx.

Hey!

I'm mostly curious about the details behind the flat-file persistence. Is the storage on the same physical machine as the API and Business Logic? If not how is communication done? How do you handle horizontal scalability for either perf or HA reasons?

For me, the biggest thing with these small linux boards is the toolchain and major distro support. I prefer making my own custom images for "production" projects.

With Raspberry Pis, you can debootstrap with raspbian, but mainline debian still requires some work [1][2] to make it function 100%.

1: https://github.com/drtyhlpr/rpi23-gen-image 2: https://wiki.debian.org/RaspberryPi

Does anyone have any information about building custom images for the Beaglebone line of boards? Is it easier or better supported? Are there any boards out there HNers prefer for their toolchain?

The iOS kernel is not open source, just the macOS version of XNU.

I love this so much. So many times I've had to install Python just for Pygments.

A static binary will be so much easier to maintain.

My ideal system is: clone a repo, run `go restore` to fetch dependencies and then `go build` to spit out a binary or `go run` to quickly start the main function.

Nothing from outside the repo can effect that build. Likewise anything inside the repo can’t effect the outside.

Compartmentalizing each project makes builds more reproducible and more obvious. If anyone else clones the same repo and runs the same commands, they should get the same result.

I love Go for the concurrency and awesome cross platform support, but my biggest complaint about Go is still the forced GOPATH.

I know this is super nitpicky, but I like to keep work and personal code completely separate and changing GOPATHs is very frustrating.

With the introduction of `vendor` and software like glide and dep tool, you no longer have to store your sources in `$GOPATH/src`.

Since dep/glide are also required for sane dependency version management, there seems to be no benefit of using `src` over `vendor`.

Without `src`, is there any reason `GOPATH` is still required?

>keep up to date on bands I like

Specifically for this use case I like Songkick [0]. Lets me know when anyone I'm following is touring near me. Lets you import artists from Spotify too.

0: https://www.songkick.com/home

Interesting. I'd love to know more about workflows around a setup like this.

Is it possible to use Xen as traditional desktop OS with Keyboard/Mouse/Monitor running X and a Window Manager? Would you run it in a Dom0 or DomU? How would you switch between them, etc.

It's projects like this that make me love hackers. Perfect combo of silly and awesome.

If you want something a little more involved, https://jaspervdj.be/hakyll/ is a static site generator that uses pandoc under the hood. Uses a Haskell DSL

Any reason you picked this over using something like Kea [1]. Because it's fun is an acceptable answer :-)

[1]: https://www.isc.org/kea/

Does https://druid.io not count as "Distributed TimeSeries database" for some reason?

I'm not really familiar with the development process between ZFS on Linux and ZFS on BSD, do these pull requests usually get merged upstream for use on BSD, Solaris, etc?

Clojure's "killer feature" for me is the by-default persistent data structures.

Are there any other functional languages out there with similar features? Lisp or otherwise.

You obviously have a strong dislike for lambda. I've never used it personally, but from afar it seems cool.

What are some of the shortcomings you ran into using it?

>Is this something you get used to over time, like reading Lisp code?

Yeah. At least for me, the thing that finally made reading Haskell and Lisp syntax was sitting down writing some.

Obligatory https://www.vim.sexy/