lominming

My main issue with many of these tests and reviews is that most of the results focus on testing the harness (in this case, likely Claude Code) rather than evaluating the model’s inherent performance.

Hey! Thanks for spending time with the playground – we're glad you found it engaging! You've hit the nail on the head with the "building blocks" analogy.

We want to emphasize that while Open Node Protocol enables no-code development, it's absolutely not limited to it. The Open Node Protocol is a specification, a set of standards for how these "blocks" (nodes) interact. Developers can build nodes in any programming language and with any framework they choose. The visual assembly is just one way to use ONP; the underlying power comes from the standardized communication between nodes, regardless of how they're built or connected. This means experienced developers can create highly sophisticated, code-based nodes and leverage the benefits of modularity and AI integration at a much deeper level. Think of it as a way to create reusable, interoperable components, regardless of whether you're connecting them visually or programmatically. In fact, in the near future, you can ask AI to assemble the nodes for you.

A great next step would be to check out our tutorial[1] – it walks you through the core concepts and helps you build your first node.

If you need more help, join us at our discord[2].

[1]: https://openexus.com/tutorial [2]: https://discord.gg/uvEPXWrmkp

I did an evaluation on the various frameworks 2 years ago, and it largely came down to only these 2 choices:

- React (if you want the largest support, packages, community, but sacrifice on performance) - SolidJS [1] (best performance, composability, low-level primitives, but sacrifice on packages/community)

Every other choice like Angular, Vue, Svelte are just somewhere in between these 2 spectrums which I felt was not worth it. Either choose the one with the largest ecosystem or one which has the best primitives & performance.

- React (vdom, slow) (largest ecosystem) - Vue (vdom, faster than react) (large community) - Svelte (fine-grain, faster) (best dx pre-v5) (composability is still not as flexible in v5 compared to SolidJS) (small ecosystem) - SolidJS (fine-grain, fastest, most consistent) (dx similar to react) (small ecosystem)

[1] https://www.solidjs.com/

Much needed feature for typography! The biggest pain is when I need to visually vertically center a text with an icon. If you have an [ICON] followed by upper case character (e.g. Hello), the (H) will always visually look too high to be vertically centered with the [ICON] because the actual height of the text that is calculated always account for hanging characters like "g, y", etc.

Great to see more people thinking about this space. Totally agree on the sentiment that we should be able to visualize/describe and build business logic in a very simple manner. The way I've been thinking about this is something like Legos where we can compose any logic, app, workflow we want visually and that anyone can build and share these blocks. This is almost similar to NPM packages, but for non-developers.

My attempt on this is https://openexus.com where the goal is really to create some form of universal plug-and-play building blocks. Your approach is almost very low-level with direct translation to code. My attempt is slightly higher-level (but developers can create as low level as they want). More importantly, the visual diagram build on openexus is a reactive graph (almost like spreadsheet), not a sequential directional flow graph (like node-red, or yahoo pipes).

Would love to chat if you are up for it. m at lominming dot com.

Obviously there are huge similarities to solid-js and other signals based framework with creating a signal, creating computed/derived, creating effects, etc. Would it be fair to say that Svelte 5 is going to more "runtime reactivity" rather than compiled time?

I'm also someone who are driven and get excited about working on something fundamental. My recent endeavor is the result of years to figuring out what can be the fundamentals for the web -- Building Blocks for the Internet.

It would be helpful to understand why you feel like version control (git, not github), a programming language (javascript), a browser, a database are all fundamentals? They are not the first in their respective categories, just that they all became popular? I feel like your examples also lean heavily towards developer only tools?

Thank you for the feedback. Did you by any chance manage to connect the first 2 cells? Once you do that, it will reveal a lot more content, with a more "regular" home page that you can scroll down.

Yahoo Pipes (or NodeRed) are what I consider “data flow pipelines” editors. These tools have very distinct characteristics: (A) usually a single piece of data or message that (B) flows through a system in one direction with (C) distinct start and end points.

Couple of core differences with what we are building:

(1) Instead of directional data flow, we have reactive data flow. For example, in the simple utility color example, [RGB Sliders] <> [Conversion] <> [HEX Color Wheel] have data flowing bi-directionally where any modules can trigger a change. Users still have the option to decide how data flows, so data flow pipelines are just a subset of what our system can do.

(2) Beyond just data or automation, we focus heavily on UI modules, allowing users to easily express interactive creations.

We actually did a mini internal hackathon among ourselves to see what we can do in 1 hour. We created a codepen (multiple code editors hooked up with iframes), spotify + lyrics + translation mini app, and a mini-dashboard.

Besides the common use-cases of creating apps or dashboards, we are excited about: AI apps and workflows, interactive education materials, a playground for kids to start thinking about logic, and hardware interface controls.

Developers can create modules in Javascript very similar to writing web components or React components. The only addition is to write a declaration of the connectors (e.g. value, data, location, etc.) and use provided functions to subscribe to cell value changes.

Developers can import NPM packages, load external javascript files, use JSX, write CSS, use Typescript, etc. We will provide all the necessary tooling online so that building a module is as simple as using an online IDE like codepen. No need for downloads, building, compilation, etc.

Non-developers can also create custom modules that consist of other nested modules grouped together. We also aim to have a lightweight way for citizen developers to write modules using spreadsheet-like syntax.

The logic is actually quite simple. Once 2 cells are connected via a line, their values are kept in-sync. If one cell changes the value, the other cell will be informed of the change, and the module will react accordingly, very much like a reactive spreadsheet.

During the initial connection, we have to “pick a winner” and determine which of the 2 cells’ values to use. The logic is that the empty cell will be overridden. If both cells have values, the direction of how you connect them determines the winner. Dragging A to B will have B’s value overridden by A’s value.

However, the developer of the module, or the creator have the ability to specify the direction flow when necessary. For example, in the Github example, the Github module populates the (issues) cell via fetch call and is expected to be a read-only cell. This means that any connection to the cell will become a directional data flow out.

The simple big picture is that we are drawing lines to tell the system how we want data to flow among the different modules, very much like how we pass variables around in code.

Clickable link: https://openexus.com

Tried "Hello" thinking that (1) it will be the easiest, and (2) probably I will get some variation of a greeting back (hi, hey, ...). Instead, I got:

Hello -> Lac

It has been >7 years since I used RoR for a complex web app. The problem is not configuration vs convention. The problem I had was when I needed dynamic front end functionality for the user (drag and drop, no-refresh edits, etc.) I ended up needing to use another framework/library on the front end too (at that time it was Backbone).

Has that been changed/improved? Or RoR is still primarily used to build server side rendering (SSR) web apps?

You are right that Sketch files (up till version 3.0.4) are actually file packages, but we support packages so it shows up as files online. This is the same as OmniGraffle and Keynote files which are actually folders. We have build our syncing technology to differentiate folders and package files.

Sketch just officially launched 3.1 two days ago which creates files that are actually single files. We can still support version control for these files, but we are working on fixing the preview generation for the new Sketch format.

Something that many people keep missing out is Automator. You can easily create a Folder Action in Automator and makes magical stuff happen. I think Automator is really underused for many people.

I should make one for myself and open source it.

Amazon Kindle Unlimited is really converging into what I talked about here: http://blog.minming.net/post/83447062229/unlimited-movies-mu....

"I feel like there’s an opportunity here for Amazon to provide a all-you-can-consume digital lifestyle at a fixed subscription price. If we could subscribe to one single service and forget about every pay-as-you-go service, it would be quite an attractive proposition."

This is becoming all too real really fast.

Really nicely done. I do not really see it in my workflow much because typing is faster than dragging around for me now and I am pretty familiar with grid concepts, but this will be very useful to explain the concepts to people. Very impressed with the dragging and snapping.

Suggestions: There are some bugs. Sometimes I cannot drag to create an offset, sometimes I can. Also, sometimes I can only resize the col from the right. Would be nice to support containers (fluid and non-fluid) and we can better visualize how it impact the behavior in relation to the width of the device. Also, I think you can easily support Zurb Foundation grid too.

Back up!

Graph API seems down, but part of the API is still up. https://developers.facebook.com/status/

1. It seems like full-res photos will be uploaded 2. Will upload both videos and photos, but there's a cap on videos 3. The storage is tied to the phone. If you sell/give away the phone, the new user gets unlimited storage. (Is is not clear how exactly this works. Do the original person still gets unlimited storage?)

That's an interesting idea. I vaguely remember coming across such symbol somewhere to convey the idea of sharing but I cannot remember where.

My first impression: "Wow. Those icons looks very Metro like Windows 8." Then, I realized the data is about City of Seattle, then it all makes sense. Regardless, good job on the city part. Providing data provides potential for the public to make more sense of them. New and interesting solutions or tidbits can be discovered from the public. I can see students playing with the data for their research papers.

Wow. I am a huge foodie and a big fan of Alinea. I am surprised they actually blog about data and thought process behind the ticketing system. I completely understand the reasoning behind this. High demand for a table at Alinea allows them to do this. I think this will work for very limited number of restaurants like Per Se, TFL, Saison, etc., but will not apply to majority of other restaurants. The big difference between Open Table vs Alinea is for Alinea, you actually need to pay upfront. The demand and the quality of the restaurant allows Alinea to do that, but again, does not work majority of restaurants when there is no single fixed menu.

Everyone is tilting their head or the device. Definitely something related to a 3D interface, but it has to be something more that just a 3D interface.

Usually layers itself do not make a PSD big. A big PSD file is usually because the DPI is huge and >500mb PSD files are very common in the print industry where designers have typically design between 300 to 600 dpi. A B2 poster at 600dpi will easily be >500mb.

*A PSD file has a max height and width of 30,000 pixels, and a length limit of 3 Gigabytes. Hence, Photoshop created PSB filetype which supports max height and width of 300,000 pixels and the length limit to around 4 Exabytes. https://en.wikipedia.org/wiki/Adobe_Photoshop#File_format

In my experience as both a designer and a developer, Git is not the right tool for most designers. Technically, Git is not ideal for binary files. When the file size is too large, Git fails badly. Git works well for text files, not binary files.

Many designers who do not code at all do not understand the workflow of Git. The process of pull, commit, push is extremely confusing. E.g. One large company that forces all designers to use Git ended up with multiple files with slightly different names in the repo system. Designers do not understand the concept of merge conflict and will just rename the file so that they can push to the repo. Case in point: the mental model of Git has worked well for developers, but does not translate well to non-coders.

Overall, I think a version control system for designers should be transparent, non-intrusive, and just works. Designers should not have to worry about when to push or pull, should not have to worry when to commit. I think it should just backup every saves and then subsequently allow them to flag specific design iterations that they want to highlight.

Disclaimer: I am co-founder of Pixelapse - Version Control for Designers.

Mother of All Demos: http://www.youtube.com/watch?v=yJDv-zdhzMY ... It is really amazing how he conceived all these in 1968 (45 years ago!). If you think about it, what we have today is just putting on a pretty UI on top of all these concepts. We hardly moved for those innovation breakthroughs that he demoed.

The problem was that some average developer was lazy and do whatever that worked, with no concern about potential security implications.