I think many of use will love to do this kind of stuff, but is mostly US companies that pay for it.
For example, I like to make RDBMs and ERPs kind of software, but here in LATAM is near impossible to get funding for it, how is in Europe?
3,329 karma · joined June 18, 2012
Rust, F#, Swift, Python.
Experience building database engines and ERP software.
Open for work and custom development!
I think many of use will love to do this kind of stuff, but is mostly US companies that pay for it.
For example, I like to make RDBMs and ERPs kind of software, but here in LATAM is near impossible to get funding for it, how is in Europe?
The problem of mixing paradigms is that get confusing. Ideally all is represented equally (ie: All errors are `Result`) but is the handling that get confusing. Each option is a totally different control flow.
And it not compose (even if you use effects ) (and I mean ergonomically*) so you need to pick wich one to make first class
P.D: I'm pretty certain about the "not compose, in practice", I have seen lots of options and none looks nice, but open to corrections!
P.D.2: It should also consider the things on the dlang handling, and the midori article...
Attempt to implement them, manually, and you see how hard is it.
PLUS, not only you need to account for the general solution, but what could be the best considering the current data set.
And, you can't compile statically (dynamically sure).
And, should work interactively, so hopefully be solved faster than run the actual query.
P.D: Joins are normally the focus, but other constructs are also challenging. For example, just solving if and which indexes to pick can be challenging when you have dozens of predicates.
And yes, your optimizer should survive(eventually!) to solve when you get feed hundreds of joins, predicates, aggregates, sorting and arbitrary expressions.
* I worked in the optimizer of a database. EVERYTHING is tricky!
I even dream of build tools for business to make apps (like Air table, but better) and even if you can do anything that do, perfectly, the software they need not means they want to babysit it all the time.
Is like the person that knows how cook, amazingly, yet hire a chef for take care of it most days.
I think the possible answer is to try to "compress" columns with custom datatypes, it could require to touch part of the innards of sql (like in postgreSQL you need to solve it with c) but is a viable option in many cases where you noted that what you could express in json, for example, is in fact a custom type that could be stored efficiently if there is a way to translate it to more primitive types, then solved that the indexes will work.
The second option is to hide part of the join complexity with views.
But I actually love my job (programming) and do it in my spare time (after program for work!) and like to join others to learn (as I have done for https://spacetimedb.com/).
Will probably dedicate the time for my dream of build a FoxPro-alternative, and pretty certain will love it for more than a decade, so if anyone wanna help get funds I all hears!
`jj` is the only tool that make me use `rebase` personally. Before, I see as the punishment given by my team wishes :)
My dream is to build such tool, I slowly doing in the side (https://tablam.org). Probably need to ask for funding too.
In concrete, what I want is a real alternative to Fox/Access that work, unrestricted, locally (including inside a phone/iPad). I don't mind have support for cloud stuff (that is what pay the bills mostly) but that is secondary IMHO.
Current computers, even mobile, have far much power than most need, and is a shame not much tools actually exploit it.
Location: Medellín, Colombia
Remote: Yes
Willing to relocate: No
Technologies: Rust, RDBMs (PostgreSQL · SQL Server · SQLite), Swift, Python
Résumé/CV: https://github.com/mamcx
Email: mamcx@elmalabarista.com
Senior software engineer with 30+ years building production systems and 3+ years working as core developer on database internals and high-performance RDBMs. Recent work includes building the internals of a production-ready real-time database used in a large multiplayer game.Founder and principal engineer with end-to-end ownership from architecture to production.
Looking for senior / staff / principal roles in Rust, databases, or backend systems.
AT ANY POINT.
No exist, nothing, that could yield more improvements that a new language. Is the ONLY way to make a paradigm(shift) stick. Is the ONLY way to turn "discipline" into "normal work".
Example:
"Everyone knows that is hard to mutate things":
* Option 1: DISCIPLINE
* Option 2: you have "let" and you have "var" (or equivalent) and remove MILLIONS of times where somebody somewhere must think "this var mutates or not?".
"Manually manage memory is hard"
* Option 1: DISCIPLINE
* Option 2: Not need, for TRILLONS of objects across ALL the codebases with any form of automatic memory management, across ALL the developers and ALL their apps to very close to 100% to never worry about it
* Option 3: And now I can be sure about do this with more safety and across threads and such
---
Make actual progress with a language is hard, because there is a fractal of competing things that in sore need of improvement, and a big subset of users are anti-progress and prefer to suffer decades of C (example) than some gradual progress with something like pascal (where a "string" exist).
Plus, a language need to coordinate syntax (important) with std library (important) with how frameworks will end (important) with compile-time AND runtime outcomes (important) with tooling (important).
And miss dearly any of this and you blew it.
But, there is not other kind of project (apart from a OS, FileSystem, DBs) where the potential positive impact will extend to the future as much.
Is not math, logic or any of that asides. Is the actual ability to read, exactly, without adding or removing anything.
The ideal flow, IMHO:
1: Emit warning, and include if possible a deadline ("will be removed in the next major version")
2: After X time, BEFORE the deadline, turn it into a compiler OR linter error, but keep the code
3: Do the appropriated notification in the channels about it of impending doom
4: Doom
If this is done correctly, we change the expectations from "warnings LOL!" to "warnings are serious business" that is missing in a lot of contexts
I used to think alike (I'm +30 year programing) until I decide to do https://tablam.org, and making a "database" is the kind of project where all this stuff suddenly is practical and worthwhile.
C has never been a particularly good language, and is so good that finally (with tons of pushbacks!) there is an alternative that make the case so strong that is at least considered the possibility that will come the very happy day where C will be our past.
The only, true, real blocker is that C is the ABI. But if we consider the possibility that C can AND should be the past, then the C Abi can finally adds sophisticated things like Strings and such, and maybe dreaming, algebraic types (ie: the C will be improved with the required features so it can evolve the ABI, but not because will be a good language for write it (manually) on it).
And to reiterate: C should finally be a real assembly language, something we not need to worry about.
As you discovered, is for you as the tool maker and for your power users. On top of that, let's say you make "widgets" or "mini apps" that are built on top.
ie: You make Django, but you ship: Shopping cart, Blog, Wiki, each with their own UI and App branding
One of them, not even use "date"/"decimal" types and all is mostly strings, there is not views or anything else, and the tables AND fields are called "F0001..".
"hello world" ? where #chars != " " == ["h", "e", ...]And because JS is on the frontend, solutions are front end, even the ones that eventually run on the (js) back-end.
Is like how people use a RDBMS but never do foreign keys, views, etc and re-invent all, poorly.
You are describing it: Things in programing were bad, then suddenly all in the upside UNTIL it start to coming down.
Is not a refute of the problem. Is to pick a moment were both were bad, and like all the discussions about tech, MASSIVELY ignore that MASSIVE internet with MASSIVE money with MASSIVE backing is worse than before.
Is like people complaining that pistols on the wild west kill as do nuclear weapons, ignoring the massive difference in size and blast damage
This is true, but it also means "the compiler IS made for someone median smart, that now knows the machine".
It works great for basic, simple, common code, and for code that is made with care for data structures.
A total mess of code is another story.
P.D: is similar to the query optimizers, that neither can outrun a terrible made schema and queries
Technologies: - Primary: Rust - Secondary: Swift, Python, Web (HTMX, TailwindCSS, JS/TS) - Databases: PostgreSQL, SQLite, SQL Server, SpacetimeDB - Systems: macOS, Windows, NixOS, Debian-based Linux, iOS
About me:
30+ years of experience across business software, databases, and language tooling.
Worked professionally with around 10+ programming languages and ~8 RDBMS systems.
Built Colombia’s leading school grading software around year 2000. Since then, developed ERP and business apps for SMBs and local governments.
Past 3+ years:
Database and compiler engineer.
---
Active member of communities around Rust, Databases, Compilers, etc
Résumé/CV: Available on request Email: info@elmalabarista.com
Yeah, this is the hard part.
I work in the small “ERP-like” business market and I’ve come up with some good ideas (based on the reaction of the people I talk to). But the problem is that even a small team of about five genuinely solid developers can cost around US $300,000–500,000 per year — and that’s even factoring in that I’m in LATAM!.
That’s a lot.
To make something like this happen, you need to convince fairly big players — the ones who have the capital and the patience, but more importantly the vision. And that’s the part that’s rare. At least in theory, that’s what VCs are supposed to bring.
Yes to the first, and must be yes to the second or we have failed!
Sql is to query languages like JS is for the web.
That is not a good compliment.
----
Sql was from the start a poor implementation of the relational ideas, and have accumulate absurd levels of tech debt.
Enjoy:
https://www.postgresql.org/docs/current/sql-keywords-appendi...
Is not that hard to come with a better alternative, but just "nicer SQL" is not good enough. We need a "Rust"-like moment for this.
My bet (https://tablam.org) is that we need algebraic data type support, real GROUP-by, a low-level language (where for example, you encode that "a = b" is in fact calling a BTree) and high-level porcelain.
The low-level language (like webassembly+relational) will unlock a necessary steps where is possible to compile "normal" SQL, that is, the thing that allows typescript to be a viable alternative to JS.
There are more details, but the above is the key. Like, you can create a proxy using the postgres wire protocol that take the SQL/Nicer lang then compiles then do the magic and is the enabler for adoption IMHO.
BTW: This is what I wanna do, so happy to join forces!
The major problem is not to find the sophisticated things, but understand how do it in simple-ish ways.
Do otherwise is a major waste of time!
P.D: And yes, only when you get the basic and learn the jargon still is a problem to find the neat tricks, but is likely that you already get that there is nothing like read the source... (sadly that source is in C or worse C++, but lately with Rust that is gaining traction at least it make more sense!)
A "barely better" version of something entrenched rarely win (maybe only if the old thing not get updaters).
This is the curse of OpenOffice < MS Office.
This is in fact the major reason:
> Great, now you just need to build and maintain shims for every tool in existence
MOST of that tools are very bad at ux! so inconsistent, weird, arcane that yes, is MADNESS to shim all of them.
Instead, if done from first principles, you can collapse thousands of cli arguments, options, switched and such things in few (btw a good example is jj vs git).
This is how could be: Adopt an algebra similar to the relational model, and a standardized set of most things millions of little tools have (like the commands help, sort, colors, input/output formats, etc) and then suddenly you have a more tractable solution.
ONLY when a tool is a total game changer people will switch.
And what about all the other stuff? In FoxPro (that in some ways show the idea you just preen `!` and then run the shell command you need. That is enough (editors and such? Much better to redo in the new way, and everyone knows that vim and emacs fan never change ways)