MiniProfiler VS TablaM

What are my options? So far I've come across MiniProfiler (https://github.com/MiniProfiler/dotnet), but I don't know how do I persists all the profiling result? Or should I not since that would takes too much disc space?

As you might expect, the king of this method is AddMiniProfiler. It allows you to set MiniProfiler up by configuring an object of type MiniProfilerOptions. There are lots of things you can configure, that you can see on GitHub.

Also you can check this library https://github.com/MiniProfiler/dotnet, which brings profiling into your existing Web application.

Re: Stackoverflow and showing profiling information on the front end, you are likely talking about Miniprofiler.

https://github.com/MiniProfiler/dotnet

> what is a good alternative to Access (or Fox, I add)

Nothing.

Access is(was) in fact a worse alternative to Fox:

- Much worse DB engine, and that is saying a lot (FoxPro db can and get corrupted. A typical functionality that was added to any fox codebase was a utility to fix it)

- MUCH MUCH worse programming language (VB) that is neither good as-is, much less as a data-programing language.

Fox/dbase is the only data-oriented language that was relatively popular and fit for the use-case.

This is by a mile the main point: Is a desert looking for languages that are made for business app/data oriented programing (and much harder looking for something not weird).

The main options: Fox/dBase/Informix(? not remember), kdb+, Cobol, SQL(when extended as store procedure lang with loops and that)

--

This point is big. Having a good form builder (that is already rare) is not enough to be a real contender for this space. You need a language where making queries is truly nice.

In short, you need a language that is `LINQ/Relational` as first-class end-to-end.

- If this lang needs an ORM: FAIL.

- If this lang needs to compose strings to make a query: FAIL.

- If exist "impedance mismatch" between data manipulation/queries and the rest of the lang: FAIL.

- It should also support super-advanced types like date, decimal, currency and ideally dimensional units. Ideally algebraic types as today.

- It should have a version of Rust `serve, Into/From` for easy conversion between data + formats.

- It should look "normal" like python/swift with `LINQ` queries.

This is the lang I trying to build: https://tablam.org

> I asked was about querying data without ever using a SQL language, like tapping directly into the data.

I agree (making https://tablam.org to try a fix & working on https://github.com/clockworklabs/SpacetimeDB in the SQL conformance).

Before I think SQL was bad. *Now I'm certain*. SQL is absurdly massive for things that could have collapse all the features 10x or more.

However, working in an RDBM now I also understand why is not desirable to make "raw" calls to the DB: The engine MUST mediate all the calls to make things works (from query optimization, execution, iteration, lock management, transaction management, etc).

Is incredible how much sophistication is in a simple `SELECT * FROM table`.

What I wish is to build a `Wasm-like` IR so that is what anybody target, and `SQL` is not the mediator.

In my case each lang I have learned (+12) I start coding a mini-ORM. I have done the same so many times, and that is a good way to learn from me. Also, I have to learn Rust building https://tablam.org.

It sounds puzzling, I start learning Rust with https://tablam.org and probably was making my life harder trying to do "advanced" stuff when not have any idea of what I was doing.

New databases.

Is probably the most "under the radar" of all. Is interesting how much attention you get from people about this stuff (when talking about implementation).

Is like, literally, only make a splash AFTER at-minimun you have something competitive with a major stablished product.

But you get more "views" talking about compilers than talking about DBs!

(except when talking about compilers that use the relational model. I probably should rebrand https://tablam.org as a "lisp"! -no accurate, but whatever-)

I will be happy if anyone joins my project at https://tablam.org.

There are many, but most never go further than SQL (ie: Are just a "query" language).

I'm trying to do it for a "general purpose" language where array + relational + functional + imperative can work together:

https://tablam.org

---

One of the biggest damage that SQL has caused is that SQL is so bad as being a programming language, is not good enough DSL and is weirdly the only game in town.

This is the deal with RDBMS. Is like: "Everyone implement a wild flavor a VM, sometimes JVM, .NET VM, Web Assembly, etc, but all use a slight variation of Java"

Is like the reverse of how things are done!

You can check how I did mine at https://github.com/Tablam/TablaM/blob/master/src/core/src/scalar.rs.

In a round-about fashion I get interested in array languages because the relational model.

I tough an array is "just a column" and somewhere I get to K and that leads me to my current attempt to build a language that make both paradigms work: https://tablam.org

I think each paradigm complement and "fill" the mission pieces the other has. For example, you can name columns, that is alone very useful!

BTW kdb+ is also on this direction but the combination is `array then SQL/Relational` and mine is `Relational then Array`.

I will be happy to get coding parters and/or funding:

https://tablam.org