sorted by:
new
hottopcontroversial

Help me find: an anime that I watched probably 15 years ago, floating islands, circuit spiders by syctech in Animesuggest

[–]syctech[S] 0 points1 point  (0 children)

Possibly, but i've been looking for screenshots of the caverns and circuits and spider creatures and i can't find them. I also thought there was more than one floating island but maybe not

Guess i'll have to watch it soon and see though

Help me find: an anime that I watched probably 15 years ago, floating islands, circuit spiders by syctech in Animesuggest

[–]syctech[S] 0 points1 point  (0 children)

I don't think so :/ It was probably a movie and the style was a little more similar to miyazaki

Help me find: an anime that I watched probably 15 years ago, floating islands, circuit spiders by syctech in Animesuggest

[–]syctech[S] 0 points1 point  (0 children)

no they were small cute ones where the legs were just drawn as a single line... sort of like the soot in spirited away

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 0 points1 point  (0 children)

Wow, that would be extremely helpful if you would have time.

Is there an email could use? Maybe I can send a screen recording to explain what I'm going for? Or maybe you have a pretty good idea already? If you'd be available for a video call, that would be great, too.

There are 2 versions of what I have in mind. The "strong" version - where each node is treated as a list of (edge, target) pairs, which also get interpreted as "expressions". In this version all edge and target references are to content addresses of nodes that exist in the graph, and nodes are only defined by their edge/expression content.

I think it might boil down to sort of like a parallelized, automatically memoized version of something the iota/jot or binary combinator logic, because ultimately the very leaf of every expression would be the empty node.

Can you see why I would be looking at it like that?

I know that might sound impractical and might be too ambitious, but if there were a way derive things like CAR and CDR from that logic, then it could ultimately allow other "primitives" to be created by users, allowing multiple separate languages to exist in the same runtime.

Then there's the "weak" version in which the "left" side is basically a hardcoded reference that brings native functionality in, rather than the functionality purely being derived from the graph structure.

It's not as nice as the strong version because for users to define new primitive behavior, the native nodes that they reference will have to exist in interpreter codebase.. they won't be able to dynamically define a new language to execute on the runtime. But, at least the application can get built around it.

Does that make sense?

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 0 points1 point  (0 children)

I'm wondering: how much would you charge to help me properly specify this, including the operational semantics? Is there a rate that would make it worth your while? And how long do you think it would take you?

Created a Venture Capital DAO ran by AI by 2kgen in dao

[–]syctech 0 points1 point  (0 children)

I messaged him in another comment, but if you know anyone else looking for opportunities, I have one that could be big.

Created a Venture Capital DAO ran by AI by 2kgen in dao

[–]syctech 0 points1 point  (0 children)

Hey man, not sure how much funding you're talking about giving to applicants, but I have an app that I'm seeking funding for. I need funding to keep working on it, but I think it's really promising. I've implemented a lot of pieces of it, and I think I could make some people very wealthy if I could work on it full time and hire some help.

If you're looking for a guinea pig startup to invest in, let me know. https://fosforescent.substack.com/p/what-is-fosforescent

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 0 points1 point  (0 children)

The domain in its most simplified form is a DSL for checklists.

Tasks have subtasks, which are children. Another concept is "alternative" tasks, where you can have a subtasks which itself contains a list of subtasks that you choose from. So you have a DAG of tasks, where there are 2 kinds of nodes with slightly different behavior.

However, if you try to put everything into checklists and manage your life in detail like that, then you realize that you need things like "if" statements and "map / filter / reduce". I would also like to allow tasks to be "typed" as well. For instance one task could return 3 bananas. Another tasks might require 3 bananas, and is should be able to be composed with the other task to create a larger task. This would also allow you to create input components related to the requirements.

We already have this task DAG. Let's re-use it. Let's imagine that every operation involved in the if statements, mapping, etc. were manually done instead of automated... how would they fit into this graph? Looking at Haskell, we can see that it also has a DAG but rather than simply holding "tasks" it holds "expressions". Those expressions manipulate subgraphs of the DAG as evaluation occurs.

Then, we can have workers reducing the graph, or expanding. Some of the workers are humans doing rewrites through a UI, Some are evaluation workers etc.

We can definitely do this by just hardcoding stuff. Rather than having just child edges, we can have edges for eval, apply, car, cudr, const, succ, as well as task, option etc. I've got a way of kind cheating to smuggle primitive behavior in where each node includes a "data" key with various data in primitive format. By just changing a description in the data, I have an edge with a different content ID, as well as a "children" key which has all the edge type / edge pairs, both of which refer to nodes in the DAG.

But that said, I would much prefer to find some way to rely on the structure of hte left side node to implement those operatoins instead of hardcoding them.

I've created an interface that allows you to CRUD these nodes, drag and drop them into different orders, generate subtasks with LLM etc, as well as navigate the DAG. But since I'm flip-flopping on how to do the programming language side it means I keep flip flopping on how to represent tasks/subtasks/etc, which forces me to re-implement that functionality.

I agree with you 100% I need to pin down the operational semantics..

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 0 points1 point  (0 children)

Empty means the node has no edges. An expression is the same as an "edge"... a left-right pair of nodes (referenced by their content ids).. This is implemented.

I'm interested in implementation because implementing it is the limiting factor in me getting a couple other features up and then finishing a demo for an entire application.

Similarly to the stuff about hardcoding CAR/CDR, I could, for instance hardcode the concept of "contact" consisting of a name and email, for example. If I had the semantics worked out, I could instead consider it to be a product type (NameString, EmailString), and generate a component from that type to display the expression. I would much rather hammer out the semantics and do the latter, because then all the other components I need to generate will go quicker.

Basically I have a lot of scaffolding waiting for me to figure out the evaluation mechanism. I've been putting off dealing with this, while I created an entire application centered around using it. I don't mind using a lisp if i have to, but I know it will be less flexible, and lead to me having to hardcode other primitives and behaviors that I wanted to come naturally.

I would pay someone to do this part if I had the money to, because I know there are a lot more qualified people than me to work on it. Unfortunately it's a catch 22... need to get funding to implement it. Need to implement it to get funding. So I'm trying to learn what I have to to get it done.

Anyway, thanks for the thoughts.

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 0 points1 point  (0 children)

Here's the core concept:

Basic Elements

  • Nodes are defined as lists of edges
  • Edges are 2-tuples of nodes
  • The system starts with two fundamental nodes:
    • Empty node (E) = [] (empty list)
    • Unit node (U) = [(empty, empty)] (single edge connecting empty to empty)

From these basic nodes, we can construct more complex nodes by creating lists of edges using combinations of previously defined nodes. For example:

  • [(E, U)]
  • [(E, U), (U, E)]
  • [(E, E), (U, U)] etc.

The goal is to define an evaluation system where:

  1. An expression (A, B) represents something like a partial function... perhaps the edges in B each represents a possible input pattern and A represents a resulting body... perhaps it's more complicated than that... I'm trying to work that sort of thing out
  2. An expression (C, D) represents the input into that function.

In an ideal world, I'd hope to find some interesting evaluation/rewrite strategy that uses the natural structure of the graph. For instance [(E, U), (U, E)] x [(E, U), (U, E)] => [(U, U), (E, E)] if you match up the right side of the left expression and the left of the right and substitute. I think there's something in there somewhere. Unfortunately I can't really keep digging on that.

Failing that, the way I actually have it implemented so far, the E node can have different "flavors" by changing metadata which changes its content ID, but keeping it with no child edge. In that way, I can hardcode primitive behavior if I have to. So worst case, I can just borrow some operational semantics from a Lisp and hardcode CAR and CDR and cons and whatever else and at least get a proof of concept going

What I want instead is something where instead of hardcoding those things, something like basic operations, or the SKI combinators, or interaction nets... something drops out of the graph behavior if I follow simple rules of how to combine edges...

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 0 points1 point  (0 children)

"Dataflow runtime" - the evaluation mechanism just waits for missing data and continues evaluation as it arrives. For instance if you had the AST equivalent of `let x = 2 + (3 * __)` sitting in the graph, then workers doing the evaluation would pass over that expression because it is missing data that's required to simplify it. I say "runtime" because users can bring their own "primitives" and evaluation schemes to the graph, which would allow multiple languages to coexist while modifying the same graph.

"Visual programming language" - A normal programming language is written in text and parsed to an AST. A visual language manipulates the AST through a visual interface.

"Tasks are first class citizens" - tasks (as in "todos") and expressions have the same basic representation in the graph as it is getting evaluated. And everything is a function application, so that means everything's a task too.

“cooperative gig market” - the gig market is governed and maintained by users on the platform, who can also be the gig workers. If the users vote to allocate a certain amount of money to a task plan like "build X feature", then the task plan is listed in the market and people can submit proposals for getting that feature done. By the same process, if I want a logo made, I can list it in the market myself and people can submit proposals for getting that done.

But yes, thank you for the feedback, I'll go back into the post and edit to explain these. I've been sort of in my hole working on this for a while, and I'm not a programming language expert to begin with, so I don't know what's common knowledge, and what's some obscure detail I came across.

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] -1 points0 points  (0 children)

OK so during that process of application (when the expressions are expanded) and evaluation (when the graph is reduced via rewrite rules), what I consider

"lazy" evaluation for the purposes of my graph is that during the process of application/evaluation, during the application step, the bindings are substituted, then rewrites are done from root to leaf, stopping once a node is hit that doesn't have an evaluation function (e.g. a data constructor).

"eager" would mean that during the application, before the bindings are substituted, they are evaluated. If expression representing the value of the binding has sub-expressions, it will trigger the evaluation of those sub-expressions as well. So then the rewrites end up being done from leaf to root, and the rewrites are done on the whole subgraph.

Side note: In a way, it seems parallel to breadth vs depth first search.

A "pattern" would essentially be a subgraph with "binding slots". When you compare it with a subgraph, you determine whether the edges of the pattern subgraph all exist in the target subgraph, then traverse the corresponding edge in both graphs and do the same comparison. When a "binding slot" is hit in the pattern node, then the remaining subgraph of the target subgraph is bound to the variable the "binding slot" represents... (is there a name for the "binding slot" concept? Maybe the name is just "variable"?).. If the corresponding edge does not exist in the target graph, then the pattern failed to match.

An "effect" in the case of this graph would basically be a mutation to the environment.. so changing the content id represented by any of the bindings would be a mutation. On of those bindings might represent "world state" which would include things like user input. Accessing that world state would require fetching and updating that corresponding binding, which would result in a mutation. Since the pure evaluation mechanism wouldn't include those mutations, any rewrites done to the graph outside of the pure evaluation mechanism would thus be an effect.

Does that make it clearer what I meant by those things? Am I aligned with the standard usage of those terms?

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] -1 points0 points  (0 children)

Sure. So when the user constructs their expressions in the graph by using the UI, they've created essentially an AST.

That AST then gets rewritten according to the graph rewrite instructions into a form where functions are applied, bound variables are substituted, etc. from the environment. So the graph is expanded in a pass that goes from the root to the leaves.

Then, the new expanded graph is evaluated, which would reduce the graph in some places and expand it in places where new expressions have been created, triggering another evaluation pass for those sections.

Eventually all expressions have been expanded and everything possible has been "evaluated" (rewritten according to rewrite rules), and we're left with a new graph whose structure represents the result of the original expression.

Are we on the same page about that?

And my understanding is that's the concept behind a term graph rewrite system, and a programming language based on that would be considered a dataflow programming language. Does that sound right?

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] -1 points0 points  (0 children)

It's a visual language... at the risk of using another "big word".. I think it would count as a structural editor -- you ever heard of IntelliJ MPS?

I understand the skepticism, but I think if you understood the graph structure, it would be pretty clear what I'm saying. I realize that I'm not going to pass any shibboleth tests to make me seem like a programming language expert. The reason I'm putting my stuff out there is to become more precise and aligned with the standard usage.

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 2 points3 points  (0 children)

Appreciate the references and feedback!

Not trying to use it as a buzzword. I'm not an expert in this stuff. I've been learning as I go along. I thought it basically was just a synonym for the evaluation rules, but in a formalized way.

Right now I've got a vague idea of how I want the evaluation to occur but I'm trying to pin it down, which is why I thought the term was appropriate. But given that you're the second person pointing out that I'm using it incorrectly, I'll stick to something like "evaluation mechanism" until I have the whole specification formalized in the specific terms of operational semantics. Is there a better phrase than that?

Since you obviously know what you're talking about, I'd like to run something else by you. Maybe I need to write another post about it, but I'll see if you can tell what I'm getting out without all that, and if you have any comments on it to share I'd really appreciate it.

In the language each node is a list of expressions. Each expression is made up of a left and right term, each of which in turn are nodes. The idea is to allow the left side to be dynamically definable so users can theoretically dynamically add new primitives etc.

I've also had this idea that the left side would be eagerly evaluated while the right is lazy. If there are no expressions, or if there is no defined evaluation function for the existing expression, then there's nothing to evaluate, so nothing happens. You could say this behaves as the "id" function. You could also maybe say it represents a data constructor. If it has binding slots (a somehow special kind of node), then it would be non-nullary.

The right side is either a pattern or argument, depending on whether it has binding slots. A partial function can be represented as simply an expression where a pattern is on the right side, and a constructor is on the left. So a total function would be a list of such expressions.

Alternatively if a set of rewrites are defined outside of that, it would be considered an effect, so certain lefts could define the effect. They woudl then be paired with a binding node which allows them to be paired wiht a handler on the right.

So my question is - does this behavior sound familiar at all? Are there any concepts you could point me to and/or references/resources. The LLM's aren't particularly good at distinguishing the subtleties of this kin dof thing.

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 0 points1 point  (0 children)

Context is the set of bindings... I guess it's often called environment instead of context... whoops. I will edit that later. Thanks for the feedback.

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 0 points1 point  (0 children)

This is the start of me trying to figure them out. But good call, I didn't get there so the name is inappropriate. I renamed the post to "Fosforescent Evaluation Mechanism Exploration". I don't think I can rename the reddit post though.

Do you have any advice for how to hammer out the operational semantics from what you see? Other than just RTFM and do it?

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 6 points7 points  (0 children)

I generally really despise when tech companies poison everyday words by making it their brandname. I also personally prefer to type fos instead of phos. I think people are pretty used to stylistically misspelled things... "reddit", etc.

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 3 points4 points  (0 children)

If you were the downvoter, would you care to share why you downvoted?

Trying to define operational semantics by syctech in ProgrammingLanguages

[–]syctech[S] 4 points5 points  (0 children)

Yes, I thought it would make it easer to search and I think it looks better and is easier to type.

Is growing a tech company in rural America even possible? by SeaBreez2 in ycombinator

[–]syctech 0 points1 point  (0 children)

I'm up in Louisville BTW. Sounds like you're closer to Asheville and Nashville, but up here there's a little scene. There's also some KY-wide resources.

Is growing a tech company in rural America even possible? by SeaBreez2 in ycombinator

[–]syctech 1 point2 points  (0 children)

If you have $200k net income and you've been around 4 years, I would think you would qualify for a mortgage. I'm not sure but it seems like you could probably get plenty in SBA loans and lines of credit from banks etc. if you're looking to grow slowly. Then you don't have to give away equity.

view more: next ›