Okay celebrating shareholder value I get in an indoctrinated pure* capitalist society.

But praising a monopoly? Wasn’t that one of the main points capitalism should prevent?

The free market brings about competitors when they are needed.

Which does not hold true in reality due to various reasons and dynamics like entry cost…

Edit: These two are related as monopoly -> big shareholder value. Still the free market should prevent monopolies. Sooo Ahhh.

That story is really sad. To me it seems like a failing of the parents/education system to not teach the son who was 17 that selling a kidney is a bad idea.

There is /s but I opted not to use it. Though using it makes the sarcasm less “fun”/rewarding for me.

I am quite surprised at the amount of people that think people exist that would praise a monopoly and celebrate sharholder value. Sadly people thinking that means that they have encountered people who hold such beliefs seriously. Which is quite sad.

I thought the second sentence made that clear but apparently not.

How did you get that downvote? Must have been a mistake.

Monopolies are good for the consumer as it makes purchasing decisions easier. Some tech markets such as the GPU one show how well a monopoly can work for shareholders.

I just wish one could donate to firefox development specifically. Then they could rid it of all the ai advertisement and tracking stuff.

I don’t think the promise chain is really needed here.

I used this script:

import Axios from 'axios'
import OldFS from 'fs'
import { PromiseChain } from '@feather-ink/ts-utils'

const fs = OldFS.promises

const image = process.argv[2]
const destination = `http://${process.argv[3]}/vfs/ota`
const now = process.argv[4] === 'now'
const once = process.argv[4] === 'once'

async function triggerUpdate(): Promise<void> {
  console.log('Uploading new binary')
  const file = await fs.readFile(image)

  await Axios({
    method: 'POST',
    url: destination,
    headers: {
      'Content-Type': 'application/octet-stream',
      'Content-Length': file.byteLength
    },
    data: file
  })
  console.log('Finished uploading')
}

(async () => {
  const updateChain = new PromiseChain()
  console.log(`Watching file '${image}' for changes\nWill upload to '${destination}'!`)
  if (once) {
    await triggerUpdate()
    return
  }
  if (now)
    await updateChain.enqueue(triggerUpdate)
  OldFS.watch(image, async (eventType) => {
    if (eventType !== 'change')
      return
    let succ = false
    do {
      try {
        console.log('Change detected')
        await updateChain.enqueue(triggerUpdate)
        succ = true
      } catch (e) {
        console.error(e)
        console.log('Retrying upload')
      }
    } while (!succ)
    console.log('Upload finished')
  })
})()

Relevent code on the esp:

You can ignore my cpp stuff and just put this in the handler of the stock webserver.

auto ota = vfs->addHandler(makeDirectory("ota"));
        {
          ota->addHandler(makeDirect([](auto &con) {
            if (con.req->method != HTTP_POST)
              return HandlerReturn::UNHANDLED;

            // https://github.com/espressif/esp-idf/tree/master/examples/system/ota/native_ota_example/main
            // https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/system/ota.html
            auto updatePartition = esp_ota_get_next_update_partition(nullptr);
            if (updatePartition == nullptr)
              return sendError(con,500, "No free ota partition found!");
            esp_ota_handle_t otaHandle;
            auto err = esp_ota_begin(updatePartition, con.req->content_len, &otaHandle);
            if (err != ESP_OK)
              return sendError(con, 500, std::string{"Can't start ota update: "} + esp_err_to_name(err), true);

            int receivedBytes = 0;
            do {
              auto end = httpd_req_recv(con.req, buf.data(), buf.size());
              // ESP_LOGE(TAG, "Received %d", receivedBytes);
              // hexDump("RECV:", buf.data(), end);
              if (end <= 0) {
                esp_ota_abort(otaHandle);
                return sendError(con, 500, "Error receiving", true);
              }
              err = esp_ota_write(otaHandle, buf.data(), end);
              if (err != ESP_OK) {
                esp_ota_abort(otaHandle);
                return sendError(con, 500, std::string{"Error writing: "} + esp_err_to_name(err), true);
              }
              receivedBytes += end;
            } while (receivedBytes < con.req->content_len);

            err = esp_ota_end(otaHandle);
            if (err != ESP_OK)
              return sendError(con, 500, std::string{"Failed to end: "} + esp_err_to_name(err), true);

            err = esp_ota_set_boot_partition(updatePartition);
            if (err != ESP_OK)
              return sendError(con, 500, std::string{"esp_ota_set_boot_partition failed: "} + esp_err_to_name(err), true);
            auto ret = sendOK(con);
            FactoryResetServiceCon().reboot(1000 / portTICK_PERIOD_MS);
            return ret;
          }));
        }

I also used a custom partition table for 2 partitions so that when my program crashes it can just go back to boot the previous version.

Here it is for reference:

partitions.csv

# Name,   Type, SubType, Offset,  Size, Flags
# Note: if you change the phy_init or app partition offset, make sure to change the offset in Kconfig.projbuild
nvs,      data, nvs,     0x011000, 0x006000,
otadata,  data, ota,     0x017000, 0x002000,
phy_init, data, phy,     0x019000, 0x001000,
ota_0,    app,  ota_0,   0x020000, 0x1F0000,
ota_1,    app,  ota_1,   0x210000, 0x1F0000,

Note: This partition table is for a special model of the ESP32 though.

Also another disclaimer: This code does not represent my current coding abilities and may be outdated - it worked well though.

Hahahah. Awesome. Have fun! You just need a simple webserver. The builtin one will do and then you use the ota functions of the ESP IDF.

Back in school my friends all flashed their mcus with 4-8MB images over serial with 115200 baud. I set up ota updates over wifi. They were all fascinated by my speedy flashes. However when I offered to help them set it up, not one was interested because their setup was working as is and slow flashing is not a “bad” thing since it gave them an excuse to do other things.

We are talking minutes vs seconds here.

The teachers were surprised by my quick progress and iterations. When I told them my “trick” the gave me bonus points but also were not interested in learning how to do ota which was very easy. A simple 20 minute first time setup would have saved sooo much time during the year.

Very interesting. I hope this passes as an actual Standart. I looked around but couldn’t find information on how to enable it in the Webbrowser. It just says firefox is not supported.

Nevermind I found the extension will try it again.

I would love a if there was a standard websites would use to receive donations. An integrated browser addon that track what you visit and gives you a review before distributing funds after each month would be great. It should accumulate money to avoid transaction fees for tiny amounts.

I don’t think a semicolon is semantically correct in this case. It suggest you want to add something. That’s why it is used in programming. You are making statements.

Maybe we should use a . after return statements to signal the end of our statement stream.

I don’t see how this gives any insight into how your subscription price is being used for products relevant to you.

And there could be insight into whether the money is actually used for developing the relevant application.

And the blinker one right? EVs still have that afaik.

The auto connect for bluethooth is really infuriating. Windows and android both don’t have options for disabling auto connect.

On linux you can only select between trust and no tust which effectively means auto connect. BUT WHY DONT THEY JUST CALL IT AUTO CONNECT.

It’s a real bummer.

I hate to break it to you but some humans…

The issue is that the web login requires their app. All major banks in my country have this requirement but I will have another look when the time for a new phone comes.

I moved over to mostly open source apps where possible. My main issue will be the banking apps that insist on safety net.

Graphene os is great on paper but I would like to buy a different brand than pixel like fairphone.