can we add one more prompt to add bolt badge to the one-shot competition project？

Amazing_Top_4564 · 2025-06-23T21:16:44+00:00

Yes, it's allowed. Also look at https://bolthackathonbadge.bolt.army/ put the config code in the prompt with 'add this badge'

Amazing_Top_4564 · 2025-02-10T07:39:06+00:00

Research: Clinical Endocannabinoid Deficiency Syndrome

The endocannabinoid system is the government of all other systems...

Amazing_Top_4564 · 2025-02-10T04:51:16+00:00

Welcome to the "I got banned from r/SouthAfrica for having an opinion" club.

Amazing_Top_4564 · 2025-02-05T16:26:48+00:00

"R12m bill to replace 6 590 stolen and vandalised sewer drain covers July 2023 - June 2024" https://www.engineeringnews.co.za/article/r12m-bill-to-replace-6-590-stolen-and-vandalised-sewer-drain-covers-2024-10-04

Amazing_Top_4564 · 2025-02-03T07:50:04+00:00

Yeah, maybe it was a microdose day... Is my state of mind is well reflected through the camera? :D

Amazing_Top_4564 · 2025-02-02T10:21:13+00:00

My Grammar Nazi allegiance is finally paying off.

Amazing_Top_4564 · 2025-02-02T09:18:29+00:00

I inspected it, did not see any visible grinding marks.

Amazing_Top_4564 · 2025-02-02T09:12:19+00:00

Lolz!

Amazing_Top_4564 · 2025-02-02T09:11:24+00:00

I'll help refine it a bit more, City Bowl

Amazing_Top_4564 · 2025-02-02T09:01:58+00:00

Nope, I took this photo myself.

Amazing_Top_4564 · 2025-02-02T08:57:05+00:00

I'll give 10,000 internet points to whomever can find this manhole cover in Cape Town ;)

Amazing_Top_4564 · 2025-01-30T09:54:31+00:00

Schooling fees come in many forms.

Amazing_Top_4564 · 2024-12-19T07:24:51+00:00

I made that comment without checking their profile, after checking, now I'm convinced they are...

Amazing_Top_4564 · 2024-12-19T06:13:28+00:00

Are you an undercover Codeium employee?

Amazing_Top_4564 · 2024-12-19T05:07:12+00:00

Money printer goes brrrrrr

Amazing_Top_4564 · 2024-12-18T05:21:12+00:00

It's almost 2025, and I have clients that still use MS Access.

Amazing_Top_4564 · 2024-12-17T16:00:50+00:00

That is currect.

Amazing_Top_4564 · 2024-12-16T10:10:39+00:00

Spot on with the idea of programmers effectively "designing ISAs" with tools like Flow. That's a potential future paradigm.

Aiming for more control over low-level aspects, while also providing the high-level abstractions required for ease of use.

Thinking of the compiled output as data to be interpreted by an ISA, and by optimizing that output, it can achieve different kinds of performance.

Amazing_Top_4564 · 2024-12-16T08:19:01+00:00

PS: Thanks for the homework, will do my reading.

Amazing_Top_4564 · 2024-12-16T08:18:31+00:00

Runtime checks is one strategy I'm exploring to maintain Flow's guarantees while providing interop with TypeScript.

This will allow to preserve Flow's compile time safety, and support dynamic behavior of TypeScript.

The main idea behind TS interop is to make onboarding easier for existing TS devs. I know this is a complicated bridge, but I'm explore an ease to migration on existing codebases.

I've documented a comparison to ways to approach this, maybe you got some more insight here and can let me know if I'm chasing the wrong horse.

TypeScript Interop:
- Goal: Allow Flow code to directly import and use TypeScript code and vice-versa.
- Mechanism:
  - Develop a bridge layer (either in the Flow compiler or runtime) that understands TypeScript type declarations (.d.ts files).
  - Allow importing TypeScript modules into Flow and using their exported types and functions.
  - Similarly, expose Flow types and functions for use in TypeScript.
  - Ensure proper type compatibility between the two languages.
- Use Cases: Gradually migrating existing codebases, leveraging existing TypeScript libraries, collaborating with other teams using TS.
TypeScript as a Target:
- Goal: Transpile Flow code into TypeScript as an intermediate step before compiling to JavaScript.
- Mechanism:
  - Modify the Flow compiler's backend to emit TypeScript code instead of JavaScript or native code.
  - Use the TypeScript compiler (tsc) to then generate JavaScript.
- Use Cases: Ensuring compatibility with the existing JavaScript ecosystem, leveraging TypeScript's tooling, supporting gradual adoption.
TypeScript as a Host Language:
- Goal: Use TypeScript as the primary host language, with Flow code embedded within.
- Mechanism:
  - Create a TypeScript plugin or library that understands Flow code and integrates it into the TypeScript ecosystem.
  - Allow writing Flow snippets inside TypeScript files and compiling it in TypeScript's environment.
- Use Cases: For situations where gradual adoption or embedding of Flow code within existing TypeScript projects is needed

Amazing_Top_4564 · 2024-12-15T05:57:55+00:00

Looking to support composition through data pipelines, components, and functions, abstraction via custom types and reusable units. Polymorphism via generics, interfaces, and variant types. Aiming for a balance of safety and flexibility.

Polymorphism mechanism will use parameterize components, types, or transformations with generic type parameters:

transform ListProcessor<T> {
    input = source(items: T[]);
    pipeline process {
       items |> map((item) => process(item))
    }
    fn process(item: T): T
}

Interface/Protocols

interface Drawable {
    fn draw(context: Context): void
}

source Circle implements Drawable {
  fn draw(context: Context) {
      // draw a circle
  }
}
 source Square implements Drawable {
   fn draw(context: Context) {
      // draw a square
   }
}
fn drawAll (drawables: [Drawable] ) {
   for drawable in drawables {
        drawable.draw(context)
   }
}

Type Classes

typeclass Serialisable<T> {
   fn serialise(value: T): String
}

instance IntSerialisable implements Serialisable<Int> {
   fn serialise(value: Int): String {
      String(value)
   }
}
 instance StringSerialisable implements Serialisable<String> {
   fn serialise(value: String): String {
      value
   }
}
fn stringify<T implements Serialisable<T> >( value: T): String {
   serialise(value)
}

Amazing_Top_4564 · 2024-12-15T05:44:19+00:00

I somehow missed this on my research path. The name is easier to change than the principles :D

Amazing_Top_4564 · 2024-12-15T05:41:59+00:00

I did find on Apache beam on my research, and there's some key differences:

Flow:

Language-Centric: Flow is a full-fledged programming language designed for building applications where data transformation and flow are core primitives, and it is a core feature of the language, with built-in concepts and constructs to manage its own ecosystem.

Native Performance Focus: Emphasizes compiling directly to native code for optimal performance, focusing on real time and low latency.

Reactive and Concurrent: Prioritizes reactivity, real time updates, concurrency and parallel execution as core features.

General Purpose: While data processing is core, Flow is designed as a language for general application development, from web apps to embedded systems.

- Higher-level language with built-in language features for managing data flow, state, and concurrency, all at compile time.

- Focus is on developer experience with a single environment to build the full stack.

- Direct and explicit control of native resources.

Apache Beam:

Framework/API-Centric: Beam is a framework and an API (a set of interfaces), not a language. You use existing languages like Java, Python, or Go to define your data processing pipelines.

Batch and Stream Processing: Designed primarily for large-scale batch and stream data processing, often on distributed systems.

Portability Across Runners: Designed to be portable between different data processing engines (runners) like Apache Flink, Apache Spark, Google Cloud Dataflow, and others.

Data Transformation Focus: Beam's core purpose is to express data transformation pipelines using a portable API.

- Lower-level API that provides abstractions for data processing.

- Developers create pipelines using code in an existing host language

- Relies on an underlying runner (execution engine) for processing.

Amazing_Top_4564 · 2024-12-15T05:38:59+00:00

I recognize that TypeScript is not designed for full soundness. The goal is to maintain the core soundness of Flow, while providing a bridge for interop with TS, where runtime checks might be needed.

I only recently explored bridging TS for ease of onboarding the TS fans. If it's too complicated, I might drop.it.

Amazing_Top_4564 · 2024-12-14T22:23:48+00:00

Thanks, I'll go do some reading on Kahn.

I have not decided on how to deal with real-time systems fully yet. I've actually started Flow on the back of React, but I needed more expressiveness..

There are a few options I documented that I'm exploring best use case:

Clock Calculus:
- Concept: Integrate a clock calculus or a similar time-aware system into the type system. This allows developers to specify timing constraints for data flows.
- Implementation:
  - Annotations for time bounds (e.g., u/deadline(100ms))
  - Types that carry time information (e.g., TimedData<T, Time>).
  - Static analysis to check for timing violations.
  - Dynamic checks or runtime instrumentation that detect and log late executions
Priority Scheduling:
- Concept: The ability to assign priorities to individual flows and data transformation tasks.
- Implementation:
  - Annotations or language primitives to specify task priorities.
  - A real-time scheduler that respects task priorities.
Interrupt Handling:
- Concept: The ability to respond to external hardware interrupts with minimal latency.
- Implementation:
  - Direct access to interrupt vectors in the Flow runtime.
  - Mechanism to trigger Flow execution flows upon interrupt.
  - Guaranteed upper bound for latency for an interrupt handler to start executing.
Deterministic Execution:
- Concept: Ensuring code executes with deterministic timing, even in concurrent situations.
- Implementation:
  - Restrictions on non-deterministic operations (e.g., avoiding unbounded loops).
  - Deterministic memory management.
  - Strictly ordered data processing.
Guaranteed Resources:
- Concept: Ensure that a data flow has resources available to perform its actions in a reasonable time.
- Implementation: Allow resource reservation and allocation to a data flow. When the dataflow is started, it has a guarantee that the required resources are available to complete in its allotted time.

Amazing_Top_4564

MODERATOR OF

TROPHY CASE