Starlord2048

[flagged]

[flagged]

[flagged]

[flagged]

Thanks for sharing, amazing visual.

This University of Chicago expansion is essentially a 135-year A/B test on institutional growth strategies versus their original design intent.

What strikes me is how similar this pattern is to tech company campus expansions. Both start with idealistic, bounded visions (think early Google or Facebook campuses) that eventually transform into sprawling real estate empires reshaping entire neighborhoods.

I'd love to see this data visualized as a time series animation - watching the property acquisitions spread across Chicago like a cellular automaton. Has anyone built tools to map institutional expansion patterns? It would be interesting to compare algorithms that could predict future property acquisitions based on historical patterns.

Also, there's a compelling parallel here to how software systems evolve beyond their initial architecture. The university started with a clean, modular design (seven quadrangles) but grew organically into something far more complex and interconnected with its surroundings. Reminds me of how many codebases evolve from elegant MVPs into sprawling monoliths that become impossible to disentangle from their environment.

What other institutions show similar expansion patterns? And what can tech campuses learn from universities' centuries of experience?

wow, ibis supports nearly 20 backends, that's impressive

I can appreciate the pain points you guys are addressing.

The "diagonal scaling" approach seems particularly clever - dynamically choosing between horizontal and vertical scaling based on the query characteristics rather than forcing users into a one-size-fits-all model. Most real-world data workloads have mixed requirements, so this flexibility could be a major advantage.

I'm curious how the new streaming engine with out-of-core processing will compare to Dask, which has been in this space for a while but hasn't quite achieved the adoption of pandas/PySpark despite its strengths.

The unified API approach also tackles a real issue. The cognitive overhead of switching between pandas for local work and PySpark for distributed work is higher than most people acknowledge. Having a consistent mental model regardless of scale would be a productivity boost.

Anyway, I would love to apply for the early access and try it out. I'd be particularly interested in seeing benchmark comparisons against Ray, Dask, and Spark for different workload profiles. Also curious about the pricing model and the cold start problem that plagues many distributed systems.

Thanks for sharing

The idea of declarative UI actions without JS is appealing

The good:

* Killing boilerplate for popovers/modals (no more aria-expanded juggling).

* Built-in commands like show-modal bake accessibility into markup.

* Custom commands (e.g., --rotate-landscape) let components expose APIs via HTML.

My doubts:

* Abstraction vs. magic: Is this just shifting complexity from JS to HTML? Frameworks already abstract state—how does this coexist?

* Shadow DOM friction: Needing JS to set .commandForElement across shadow roots feels like a half-solved problem.

* Future-proofing: If OpenUI adds 20+ commands (e.g., show-picker, toggle-details), will this bloat the platform with niche syntax?

When we talk about making AI safer, we often slide into paternalistic frames where we dictate outcomes rather than enabling capabilities with appropriate guardrails. The distinction she makes between providing capabilities and forcing functions seems critical.

I'm curious if anyone has explored applying Nussbaum's theory directly to AI development frameworks. What would her capabilities list look like for artificial intelligence? Could this be a more productive framework than current alignment approaches?

Between LLVM's optimization passes, static analysis, and modern LLM-powered tools, couldn't we build systems that not only identify but automatically fix these performance issues? GitHub Copilot already suggests code - why not have "Copilot Performance" that refactors inefficient patterns?

I'm curious if anyone is working on "self-healing" systems where the optimization feedback loop is closed automatically rather than requiring human engineers to parse complex profiling data.

500 years ago, betting on the Pope was punishable by excommunication. Today, crypto-powered prediction markets are placing odds on the next conclave. Have we come full circle, or has technology fundamentally changed the ethics of speculation? Should there be limits to what we can bet on, or is ”information price discovery“ an absolute good？

Are decentralized prediction markets a net positive for transparency, or are they just incentivizing bad behavior?

would be glad to see benchmarking results

I agree with you that there is still room for improvement when it comes to the efficiency and effectiveness of training orchestration tools. It's true that setting up and spinning down GPU instances can be challenging, and optimizing the use of these resources is essential given their cost.

It seems as though the main issue here is not with FP itself, but with the politics and power dynamics within organizations.

I am loving this tool. This is a great example how we can automate information flow between technical communities and foster faster response and technology iteration.

FYI, Sohu is one of largest Internet companies in Asia. It has been a NASDAQ listed company since 2000. https://en.wikipedia.org/wiki/Sohu

disclosure: I am with the Milvus team.

Milvus positions itself as an open source vector similarity search engine built on top of various ANNS algorithms,including Faiss, Annoy, HNSW, etc.

As a vector similarity search engine server, Milvus is designed for easy to use, high reliability, easy to scale, and high performance. Milvus supports near real-time search, CRUD, WAL, data consistency, distributed deployment, high availability, and more.

Hope this answers your question.