NWoodsman

Is there a jellyfin server that is an application? I might have mistakenly assumed it was container-based or itself a minimal OS.

I forked a simple DNLA server which has been dead for 10 years and updated it to .Net 9. The goal is that hard drives are too expensive now and so it's better to spin up media servers quickly and temporarily using whatever hardware you have on hand.

It currently builds and announces itself to my TV (can see the server in Roku Media Player) but crashes because the http server implementation is homemade and out of date. Copilot generated some options and I will be plugging an implementation of a sockets-based server in the next couple of days.

https://github.com/NWoodsman/simpleDLNA.net

I just posted my recorder app that does the same thing. I use NAudio WasapiLoopbackCapture. it's written in C#

https://github.com/NWoodsman/SimpleRecorder

A simple one click just works mic+PC audio recorder for Windows that mixes the microphone into the PC sound.

This post has a lot of similarities to the 'object algebra' paper by Bruno Oliveira.

https://www.cs.utexas.edu/~wcook/Drafts/2012/ecoop2012.pdf

If the OP author has any interest in doing a 1000x service to the C# community, the community needs a translator like you to convert the paper's compiler example into other domain specific examples. I'm pretty sure this paper went nowhere because it lacked a hello world example. something easier to digest and smaller and scope. The classic "dog is an animal and cat is an animal" level of explanation.

I am a fan of this particular repository by Jules Jacobs who similarly uses struct based generics (to create immutable collections.)

https://github.com/julesjacobs/ImmutableCollections/discussi...

It has similar "source generator" hallmarks like in OP's post, for example calling a generic constructor which is JITted to a deeply nested struct type.

It's (in my opinion) very hard to reason what the code is doing because it has that flavor of "writing code to generate source to generate code"

It's impressive. And i'm pretty sure it's only real hinderance, why it could not be adopted into the base library, is that the repo needs a phd holder to finish implementing the `IList` interface because deleting is really difficult and theoretical.

It needs to be WebScript of course!

Also will throw in to the mix, in C#:

https://julesjacobs.com/2014/11/11/immutable-vectors-csharp....

His implementation uses buffers of capacity 32, generics, and bit shifting to do lookups.

Sage is a programming language with a low level virtual machine based on a Turing tape. The sage virtual machine has a read/write head and a single register. The read/write head moves around the tape, and uses the register as an accumulator. All worldly input is done through a single instruction, and all worldly output is done through a single instruction. Functionality which cannot be achieved with any algorithm, such as using an operating system’s system calls to write to persistent memory, is also done through two instructions: one for sending values to the virtual machine’s foreign function interface, and one for receiving. The goal of the virtual machine is to allow algorithms to be expressed in the same time complexity as they would on x86, but with the smallest possible number of instructions. This allows sage code to be maximally portable: sage’s core instruction set could be implemented in hardware much easier than any modern architecture due to its very small pool of opcodes and their simplicity

This is an interesting snippet from your website, did this project intentionally start out as an attempt to design around a Turing machine? Or is it just safe to say that all languages executing on a stack with no heap are Turing machines?

Pretty cool tech. I helped my dad experiment with stitching his artwork but he eventually decided to rely on a Betterlight scan back for a large format camera.

The inventor of the Betterlight made limited number of the devices with an experimental large format CCD made by (Nikon? Canon?). He since passed away and there's a small community of owners desperate to keep their scanners operable, it's a near exinct tech. They allow for ~500 megapixel scans of artwork.

By placing studio lights above, shooting down, we capture the shadow and relief of the paint.

There are too many variables and edge cases to parse data. Dozens of text encodings, mixed with dozens of markup languages, mixed with millions of uniquely preserved legacy datasets, results in an exponential number of edge-case requirements that the world's data is currently stored in. And when you consider the high-power companies with financial investment in legacy data, as well as high-power companies protecting the proprietary rights and trademarks of their existing formats, the world has maximum incentive to use the status quo, a postscript-generated PDF which, due to it's legacy, happens to lack the structure you want.

On a more philosophical level, the PDF has structure which is probably the most generalized structure across all domains: paragraphs of text on a page. Consider that most people barely know how to search a text file for a given word, and a minuscule percent of those people who know how to query a SQL database. People simply do not have the time or resources to learn a separate domain (data structure design and interaction) apart from their own domain. In other words, there's very few people who understand or even have motivation to use tools that provide exponential return on their time (such as manipulating/filtering/working with structured data). Time passes uniformly, and you typically receive no reward other than more work for learning tools to improve your own workflow.

Software engineers have long noticed that we can successfully create "models", "view models", and "views" of data that achieve the separation of concerns that you are seeking. A PDF is nothing more than a "view" of data, which has passed through a professional who has created a "view model" of that data (he/she decided how best to organize the data on to the page), and then you read the document and "parse" the data with your intellect. There is a lot of expertise and professionalism embedded in crafting paragraphs (or other graphical representations) that you can't discredit.

There is very little software options to treat generalized, domain-specific data in this three-step manner.

You might like this thesis:

http://www.bloechle.ch/jean-luc/pub/Bloechle_Thesis.pdf

I made a HN post on this here: https://news.ycombinator.com/item?id=33674525

Unfortunately I contacted the author via youtube and the work is proprietary, owned by the business he either created or sold-to.

Change my view: given any data storage medium, the smallest granularity of data must also be the most-child element of any markup language. Given the immense overhead of storing markups on a granular level, processing markup therefore must be a perpetual exercise in recursion.

I.e.

      Poem->Verse->Line-> <char>

      Book->Page->Chapter->Paragraph->Sentence->Word-> <char>

      HTML->Body->Div->P-> <char>

Domain: Poetry, Value: Line

Domain: Book Object Model, Value: Word

Domain: HTML, Value: P Element

We could then ask any letter arbitrarily "what is your Font Style in your HTML context?" and it would be able to walk up the parent P which obtains its style from a CSS markup, and return that correctly. Or "What is your Poem's name in your Poetry context?" and it could recurse up to the Poem element to find it's Title.

For those who want to try, here are the steps I took over about an hour to set it up:

1. Downloaded the Win10 artifact: https://github.com/ggerganov/whisper.cpp/actions/runs/363552... at the bottom of the page by logging in to Github. Extract and placed this folder in my F:\ drive renaming it to 'Whisper'.

2. Downloaded `ggml-large.bin` here: https://huggingface.co/datasets/ggerganov/whisper.cpp/tree/m.... Within F:\Whisper, add a folder named 'models'. Move ggml-large.bin to the 'models' folder.

3. Downloaded ffmpeg, extracted the archive to F:\FFMpeg, and set the environment variable by going to (right click) This PC -> Properties -> Advanced system settings -> (Advanced tab) -> Environment Variables -> click Path -> Edit -> (paste in ffmpegs path i.e. F:\FFMpeg\)

4. Use PowerShell to run ffmpeg against an mp3 file, to convert it to WAV (which is the only format that works) i.e.:

ffmpeg -i F:\Rec\input.mp3 -ar 16000 -ac 1 -c:a pcm_s16le F:\Output\output.wav

5. Open PowerShell again, `cd` to the Whisper folder, and ran this:

./main -m models/ggml-large.bin -f F:\Rec\output.wav

Ok nevermind, figured it out, it requires login. Then the archive is at the very bottom of the page.

Can you expand on your steps a bit more? I've never used Github Actions which seems like step 1. Not sure how to get an installer.

Is it possible to do an API request to find greatest price differential compared to historical price of items with > 1000 reviews?

An interesting thesis from 2010 showing PDF document reconstruction via machine learning in order to rebuild a PDF with an object model.

Can anyone shed light on what the state of this art is currently?

Is your design open-source? Do you have an API? Would like to learn/help

I understand your pain, but want to make you aware that LINQ has become so powerful especially with lazy evaluation and expression trees that hierarchical views of tags is really basically simple and actually just one more method of visualizing data...

In my app, users apply a set of tags to a note, but then the app automatically creates hierarchical associations in a tree. There are an exponential number of associations between tags (At one point design was failing because it was trying to prebuild 100k+ GUI items for these cross-referenced tags) so I had to virtualize the intersection of tags at the exact moment a user expands a tree item.

You cannot plan what tag search will lead you back to the data you want, so every node in the graph must be bidirectional.

Was the juice worth the squeeze, or should I stick with a trusty mechanical?

Historically military slang referred to the “regulars” which was the way to say “they guys you call upon to get dirty” and would mean different things depending on the army… a British regular would be a redcoat conscript, a US regular would be a militia volunteer from one of the colonies.

Guns were not issued to citizens, but were owned personally. It makes sense that the resulting law would read “we want the ability to have a militia and have those guys bring along their guns”. Especially because there was no standing army at the time, it was envisioned that the US Army was simply a way to refer to a conglomeration of state militias, not an organized Army.

I was going to say "a better version of C#" but maybe an entirely different language would be better.

C# uses stack and heap for memory management, which is to say this is an entire language designed around memory management. Should memory management be a core of a modern programming language? Available memory has expanded like 1000x in the lifetime of this language.

I wonder if modern government space launch vehicles ultimately represent the pinnacle of gamification of government contracting moreso than technological achievement. You could definitely argue that the Apollo missions interacted with newborn mega corporations which have matured now. Not just their products have matured like rockets and guidance systems, but the ability to play the contracting game and get wildly exponential big bucks and still convince everyone the budget is still too small.

You could try my app, it’s free.

https://paperbirch.app/notes/notes.html

A lot of space is wasted on the "cards" style scroll design. Which means I rapidly lose interest scrolling at all, I did it once, won't scroll down again.

The header with the "recommended based on people you follow" message is obtuse information i don't need to know. There would be more magic if the algorithm didn't say why this item was chosen for the feed. And the header style wastes space.

Invoking the soul of git is always the most conceptually pure design inspiration. therefore, git-relevant facts are always more effective than social-relevant facts.

// example

<User> in <Repository>: 2 commits: Removed unused code Refactored x function

// example

<Repository> Released <Tag>: Xth release since <LaunchDate>

//example

<User> branched <Repository.MostRecentlyWorkedOnBranch> to a new branch <BranchName>.

//end examples

This would be a dense view of chronologically-relevant feed information that can be digested quickly.

The only other information that i find useful other than standard git data based information is 1. when readme.md is updated, and 2. when media is added to the readme of starred, watched, and algorithm-discovered repos.

When a commit of readme.md occurs, extract the markdown of the commit, render the markdown in a feed post with a link to the repo/readme, so i can read it in context.

source?

(I only ask because you sound knowledgeable and your answer implies some hefty interesting legacy)

A better way to put it is OP is a "reverse engineer" whereas you sound like a "forward engineer"

Appreciate the feedback. I have a question for you: do you realize that making something open source means you lioeters the person gets to use it, but it is also possible that a corporation can use it and install hundreds of instances of it? I simply don't think that is fair. I think a license that makes usage free for personal use is fair, and a corporation can pay a fair price to deploy it.

I understand now that maybe HN is not the target audience for my app. The value of my app is runtime usage, not extending and modifying the source.

If you trust that Windows will support legacy versions of apps (true so far), and you are ok with a free but proprietary license (use freely in perpetuity as long as you can get a copy of the portable installer)...and you want to save plain text data via version control... maybe try my app: http://notes.paperbirch.app.

It's not for marking up documents or drawing, let's say that data-storage and recollection is the main use, it might help you.

BTW, the use of tags allows you to quickly "view the world" from a particular set of words, "work,project,todo" is a pretty specific domain and my app is designed to let you work within that domain or simply change tags to view the world from a new domain.