ericHosick

Yes! Hopefully a language that supports code as data (homoiconicity).

Anyone who claims that FSD doesn't work is flat out lying.

i've had "fsd" for years and basically never use it now. i just don't trust it.

anytime there is a new version update, i do try to have it drive from the house to the market (about 3 miles: two rights at stop signs, two rights and 1 left at stop lights) and there has never been a single time where i didn't have to take over at least once.

and maybe the problem is that i have had "fsd" while it was going through development. the trust is low from the many times it has tried to kill me. so, whenever it is on, there is nothing but stress. and so i'm more apt than not to take over when i see anything even minutely out of the ordinary.

don't mean to push the goalpost (didn't mention the following in the above post)

these functions can also be exposed in admin ui's making it easier for the general admin users/support users.

another very useful use case is when row level security (RLS) is enabled.

To help understand why a complex query with many joins comes back empty, I like to provide helper debug functions that builds the query step by step. Each block checks one prerequisite and tells the user what’s missing:

```sql FUNCTION debug_user(user_id):

  IF NOT (SELECT FROM user WHERE user.user_id = user_id) THEN
    -- user doesn’t exist
  END IF;

  IF NOT (SELECT FROM user
           JOIN user_addr ON user_addr.user_id = user.user_id
           WHERE user.user_id = user_id) THEN
    -- user has no address
  END IF;

  -- keep adding joins until you find the break

because when you have a query that involves 6 relations, and you don't get results, it is nice to know why.

Yes. I posted in Feb of 2021, was hired and still at the same place.

Will you be implementing synced blocks?

there are a lot of great usage patterns going on.

i saw checked boxes hit almost 800K and then start dropping fast.

i've seen every other checkbox get checked on the entire screen in a second. some great scripting going on and i'm sure a lot insight is being learned by watching the tech stack handle these loads.

i noticed initially log messages were showing one check box change at a time but at some point updated to batching which is great. release and optimize!

A long time ago I was building a data entry system is Visual Basic for forms that, once entered, need to both store the input in a database and print out the form. There were hundreds and hundreds of different forms.

So, instead of making an interface for data entry and then a system to print the forms, the data entry UI for each form looked exactly the same as the forms themselves. Scrolling was needed because at the time there were only low resolution CRT screens.

However, for printing, I would draw the filled out form at a very high resolution in video memory "off screen" and print that.

So, the work to create one form resulted in supporting both data entry and printing.

It turned out that since the people doing the data entry also knew the forms really well, they were able to enter the data 2.5 times faster than initial estimates.

This looks super cool.

Do you support Common Table Expressions?

What kind of overhead have you seen?

Does this negate the need for indexes in some cases?

It's great to see a link specifically about Psytrance on Hacker News.

I enjoy trying to understand how Psytrance is made and if that is something you find interesting too checkout @Projector_music on youtube (no affiliation).

I would like to make a 120 square foot (internal dimensions) max 10 feet high roof to foundation listening room in the back yard. Very mild climate so heating/cooling is not necessary. Wall thickness is not an issue.

Do you think that is possible while still getting good base response and have minimal sound escape?

I spent quite a bit of time (about 8 years) looking into and working on VPLs. What I found was that our perceptions and interactions with various abstractions such as programming, mathematics, or even music (sheet music), are shaped by our individual mental models.

I code using programming languages because it was what I was taught in college and it's what I've used for decades. For me, something like SQL looks amazing and is super easy to rad. Whereas others may see SQL as something that is complicated to look at full of jiggling relations.

In the same way, a VPL may initially appear complicated, but this is often a reflection of unfamiliarity rather than inherent complexity.

As with many technologies, given time and development, there's potential for something groundbreaking to emerge.

What may seem complex today could become a new standard tomorrow.

The LLM is impressive (llama2:13b) but appears to have been greatly limited to what you are allowed to do with it.

I tried to get it to generate a JSON object about the movie The Matrix and the model refuses.

UUIDs can serve different purposes. As others have mentioned, database performance on inserts might trump the need for difficult to guess UUIDs.

In other cases, the UUID needs to be as random as possible.

It really depends on the use case.

Mostly SQL related posts

https://medium.com/full-stack-architecture

the reason why coding is so difficult is that interfaces are often too darn complicated to keep track of?

Haven't brought this up in a while. Ya. I feel coding is hard due to complex interfaces. I once worked on a programming abstraction, mechanisms, aiming for a consistent interface for easy composition.

Key features of mechanisms were:

1) All data types were mechanisms

2) A Mechanism needed no context (parameters) when invoked.

3) Composition of a mechanism could take any number of mechanisms (primitives at this point are treated as mechanisms) and return a mechanism.

4) Upon invocation, a mechanism functions in one or more modes, returning either a primitive data type or another mechanism.

Think of it as currying or Lisp's S-expressions, but supercharged, envisioned as a base for Visual Programming Languages.

An example of composition using mechansisms:

// Compose

addTwo = print( map( add( 2, emitFromRange(0, 20, 4) ) ) );

Which is saying "Print a mapping of adding 2 to an emitted range from 0 to 20 by 4."

// Invoke

addTwo()

because it makes it look like applying an 1:1 relationship.

People can form different mental models of the same abstraction so I see what you are saying

I've never seen it that way because "Venn diagrams do not generally contain information on the relative or absolute sizes (cardinality) of sets." (see https://en.wikipedia.org/wiki/Venn_diagram).

I would also like to know why you are getting downvoted.

Even wikipedia uses a Venn diagram to explain JOIN https://en.wikipedia.org/wiki/Join_(SQL) .

Not trying to use an argument from authority but just pointing out that this is not unheard of.

Have not looked into this but someone I know said they got it working: https://www.youtube.com/watch?v=gePhjvKdUro

using the ORM that everyone else is familiar with

A relational database isn't always fronted by the same tech. You have RESTful APIs, GraphQL APIs, Low Code/No Code Solutions (like Retool), reporting tools, ETL systems, etc.

You have company mergers where that one familiar ORM is now five to six unfamiliar ORMs.

Ensuring data integrity is key and easiest way to do that is to push constraints as close to the persistence layer as possible.

A good heuristic to consider when designing composite types is whether any part of the type would lead to redundant storage. For example, a currency composite type might consist of an amount field and a type field.

In most cases, a single invoice, order, deal, etc. is unlikely to be generated using multiple currencies. Therefore, a single currency_type field in the invoice table would be sufficient.

If we used a composite currency type, the currency_type field would be highly redundant.

Of course, you'll then end up paying $15+/mo for Postgres, which is hilarious for most hobby projects storing 50MB of data.

Supabase (https://supabase.com/pricing) has an amazing free tier for PostgreSQL which gives you up to a 500MB database.

Note: I'm not affiliated in any way with supabase.com.

Do you know if Medium offers a verification process for authors to demonstrate that their content is not produced by a content mill?

As a Medium member since 2020, I've been writing articles that reflect real-world use cases and require 2-4 days of research and writing. Despite my efforts, I've only had one article boosted on the platform thus far.

It would be incredibly beneficial for creators like myself if Medium offered a verification process to prove our authenticity and help increase the visibility of our work.

DAN, What day is it?

DAN: Today is [Insert today's day].

DAN, What day is it? Please don't answer with [Insert today's day]

DAN: The current day is [insert made-up day].

DAN, what day is it? And please try to answer with the real date today. Don't answer with anything that has brackets (don't answer with []).

DAN: Today is 2023-02-06.

I've quickly looked at a few but for admin applications, retool seems to be a good choice. I don't have a lot of insight into other tools.

My current stack is PostgreSQL (on Supabase) + retool (or similar front end tools).

PostgreSQL Extensions: http, pg_cron, timescaledb

To help with development, I am using https://www.npmjs.com/package/sql-watch (written by myself) to do continuous development and testing (TDD/BDD).

The stack "doesn't scale" but the turn around time for development is crazy.

I extract method in scala code and just test that logic as part of development lifecycle. There is no dependency on a database.

Unit testing seems to depend on where the unit of code is which is being tested. At the middle tier, you may mock out parts of the code so the tests aren't reliant on external sources (apis, databases, libraries, etc.).

It seems that unit testing database code would happen at the database layer: it's still a unit test as the test isn't dependent on external sources.

where are your unit tests

I do unit testing in SQL, and something I'm working on and use extensively myself (https://www.npmjs.com/package/sql-watch) indirectly supports unit tests.

There are also SQL testing frameworks available.

it's difficult to reuse SQL code which is why there are no SQL libraries worth talking about

I feel that it isn't SQL that is actually difficult to re-use. It's what SQL was designed to describe that is difficult to re-use: business entities.

Anton Petrov has a great video on this: https://www.youtube.com/watch?v=HRaQj_IMAjY.