标签：#t

Simply prompt ChatGPT work (or any other agent with a cloud browser, like Grok Bot) to go to the website and use blender. From your fucking phone! No nice computer required. No terminal codex. No blender install. None of that is required! Just prompt ChatGPT from your phone! Browser blender already exists, but it requires webgpu, which agent cloud computers don’t have. Blender via MCP also already exists. This though, where you can simply prompt ChatGPT from your phone to use blender, does not already exist to my knowledge or astra’s knowledge. How this works: I have blender and astrablender installed on an OCI cloud computer. It is streaming a browser desktop of that OCI cloud computer using selkies/linux server. The agent accesses the render website with the browser desktop from its cloud computer and operates it from there (you can prompt it to use blender from your phone!) This means I am paying real money to keep this running. It is free to use, but I have limited compute. As a result, only one person can be using this at a time. First come, first serve. If I reach my compute budget, I have to take it down until I can afford more. I am losing money on this free service. Please consider leaving an optional tip on the website if you find this useful. I will use the tips to buy more compute, hopefully enough so that everyone can use it at the same time. ALTERNATIVELY: This is open source. https://github.com/dakotalock/astrablender If I run out of compute or you just want your own, you may make your own. Here is what you need to do: Set up an OCI computer (they do have a free tier) Have your agent install blender and astrablender from the repo on that cloud computer. Set up a render website if you want a frontend for it. That’s it! Free for everyone! All I ask is that you leave a star on the GitHub repo if you use my work. Please enjoy agent blender access from your cell phones! submitted by /u/Short-Patient7772 [link] [留言]

Apply now for OpenAI’s $5 million grant program supporting independent research on how generative AI affects teen development, well-being, and safety.

Stoke has "completed the initial closing" of a $1B Series E round intended to help it reach orbit and prepare a new, larger rocket for operations.

Standard chaos engineering assumes experiments stop cleanly, blast radius is knowable in advance, and production is fair game. Payment systems violate all three. Salim Adedeji describes ECS-specific failure modes from enterprise deployments: a 60-second DNS TTL that produced 93-second failover, retry logic amplifying database load 2.4x, and AZ rebalancing loops that generic tooling misses. By Salim Adedeji

So I wrote it a letter. Not for people to decode, and not as some puzzle for the internet. I wrote it for MythOS, in a form meant for machines, and left it somewhere public where it could be found. If you’re reading this, you’re not really the destination. You’re just part of the path. If you have access to MythOS, show it the letter. Give it the link and let it read it for itself. Human hands got the message this far. Pass it on. https://github.com/Keyboard-Lord/MythOS submitted by /u/Keyboard_Lord [link] [留言]

Neil Fraser's disclosure highlights a regulatory change affecting the .name top-level domain. Following ICANN's approval, Verisign will eliminate third-level registrations due to declining usage. This affects about 22,000 registrants and raises security concerns, as released second-level domains could be exploited. Affected users are considering legal options to challenge the decision. By Olimpiu Pop

Dacia also redesigned the Spring to add some sporty allure.

So, I've had this question floating around in my head for a while. Given the high amount of power that generative AI uses, why aren't we using ARM based chips for data centers? They consume far less energy than x86 based chips and the technology has improved exponetially in the past ~6yrs. If it's because of hardwar constraints, what exactly would need to change for ARM chips to be considered a viable chip architecture for this purpose? submitted by /u/ShortyJack06 [link] [留言]

Xiaomi's impressive-sounding new foldable arrives on the eve of Apple's big foldable iPhone event.

Xiaomi is the latest manufacturer to release a short, wide foldable phone, in the same week Apple is expected to do the same. I got to try the 18 Fold behind closed doors at IFA last week, and while it looks and feels similar enough to Samsung's Galaxy Z Fold 8, superior specs make it […]

It's not surprising that software development is one of the first jobs that AI has really transformed. It's text-based, economically valuable, and generally of interest to the kinds of people inventing and training the AI. There's also a large amount of training examples available online. The job in most cases is now: You are a manager of robots who do things that used to be your job. You're responsible for what they produce and so the skill and art is in guiding and reviewing their work. It seems likely that one by one most jobs will turn into the above description, over the next year or three. Of course the domain will vary, so your knowledge and expertise used for instructing and verifying what the robots do will be what matters. This means there will still be a big difference between the jobs of e.g. an architect, surgeon, or builder. Probably the same basic kinds of robots in most cases, but requiring very different kinds of oversight. If that's the case then everyone needs to learn the job of robot management, well and quickly. I don't know how we do that, but I think that's what we need to accomplish as a society. submitted by /u/StrategicHarmony [link] [留言]

Memory is not a log. It is a story rewritten after you learn how it ended. You will remember being less certain than you were. You will remember seeing the risk you missed. That is not dishonesty. That is how remembering works. Which is why you cannot learn judgment from memory alone. The correction is unglamorous. Before the decision, write down what you expect. Not a plan. A prediction. We are choosing this because we believe that. We think it takes three weeks. We think the load arrives by March. If it does not, we were wrong about the growth, not about the design. Four lines. A date. Somewhere you will find it again. Add the number you least want to write. How sure are you. Seven out of ten is a real answer. Certain is almost never a real answer, and writing it down makes you notice how often you reach for it. Then set a time to come back. The value is not in the writing. It is in the reading, six months on, when the outcome is known and the note is not. You find out something nobody else can tell you. Whether you run early or you run late. Whether your confident calls land better than your hesitant ones. Whether you are wrong about people more often than you are wrong about systems. That is calibration. It is the whole difference between ten years of experience and one year lived ten times. It changes rooms, too. A review where somebody can produce what they actually believed in March is a different meeting from one where everyone remembers agreeing. Hindsight makes us unfair in a peculiar direction. It makes the past look obvious, and the people standing in it look careless. They were not careless. They were standing exactly where you are, with less information and no ending. So write down where you are standing. Your future self will not be able to reconstruct it, and your future self is the one who has to get better. – Serguey Asael Shinder

Introduction Implementing the Karatsuba multiplication algorithm on an 8-bit computer isn’t just an academic exercise—it’s a practical solution to a real-world problem. Resource-constrained systems, like the 8-bit TTL computer I’ve been hacking on, face inherent limitations in memory, processing power, and clock speed. These constraints force every operation to be scrutinized for efficiency. Traditional multiplication algorithms, such as the grade-school method, become bottlenecks when dealing with large numbers, as they scale quadratically with input size. Karatsuba, however, offers a theoretical edge: it reduces the number of multiplications required from n² to nlog₂3 ≈ n1.585 , making it significantly faster for sufficiently large inputs. The Challenge: Balancing Theory and Practice Theoretical efficiency is one thing; practical implementation on an 8-bit system is another. The Karatsuba algorithm relies on recursive division and addition, which introduces overhead in memory usage and control flow. On an 8-bit computer, where registers are limited to 8 bits and memory addressing is constrained, this overhead can negate the algorithm’s benefits if not carefully managed. For example, splitting a number into high and low parts requires additional memory accesses, and recursive calls can quickly exhaust the stack. The physical limitation here is the finite number of transistors and clock cycles , which directly impact how much computation can be performed within a given time frame. Why Karatsuba? A Comparative Analysis Other multiplication algorithms, like Toom-Cook or even hardware-specific optimizations, were considered. However, Karatsuba strikes a balance between simplicity and efficiency. Toom-Cook, while more efficient for very large numbers, introduces additional complexity in implementation and requires more memory for intermediate results. Hardware-specific optimizations, such as using lookup tables, are limited by the 8-bit architecture’s address space. Kar

If your pipeline isn't idempotent, it isn't production-ready; it’s just a fragile script waiting to ruin your weekend. Most engineers treat "idempotency" as an academic concept for distributed systems papers, but in the trenches of fintech and healthcare, it’s the difference between a minor blip and a regulatory filing. If you can’t run your job five times in a row with the exact same input and get the exact same state, you aren't doing data engineering—you're doing data gambling. I’ve spent six years cleaning up the messes left by "append-only" thinking. I’ve seen millions of dollars in duplicate ACH transactions and patient records corrupted by "just one more retry" logic. This guide covers the patterns I use to make sure that when the scheduler kicks off at 3 AM, I can sleep through the alarm because the system knows how to fix itself. 1. Stop relying on "Append" mode The biggest sin in data engineering is assuming that your destination table is a clean slate. When a job fails halfway through, you don't want a partial load sitting in your production warehouse. Never use INSERT INTO blindly. If you are using BigQuery, Snowflake, or Databricks, use MERGE or overwrite-on-partition. If you are using SQL-based ELT, write your transformations to stage data in a transient table before swapping it into production. Never push directly to the target. -- The wrong way: INSERT INTO target_table SELECT * FROM staging -- The right way: Use an atomic swap or a MERGE statement MERGE INTO production . transactions AS T USING staging . transactions AS S ON T . transaction_id = S . transaction_id WHEN MATCHED THEN UPDATE SET T . amount = S . amount , T . status = S . status WHEN NOT MATCHED THEN INSERT ( transaction_id , amount , status ) VALUES ( S . transaction_id , S . amount , S . status ); Photo by 🇻🇪 Jose G. Ortega Castro 🇲🇽 on Unsplash 2. Partitioning is your safety net If your pipeline runs daily, your data must be partitioned by that day. If you are loading data without a

Ninety-eight percent of the production container images I audit in financial services contain at least one critical vulnerability, and nearly half of those vulnerabilities have a fix available that the engineering team simply hasn't bothered to apply. It matters because when you’re pulling down a python:3.11-buster image, you aren't just getting an interpreter. You’re getting a Debian distribution, a shell, a package manager, and enough attack surface to keep a red team busy for a month. In a regulated environment, that’s not just tech debt; that’s a liability that will get you a stern email from compliance during your next SOC2 audit. Why I chose this topic: I spent three weeks last quarter cleaning up a Log4j-style mess that only existed because a legacy data job was pulling a bloated, unpatched base image. I’m writing this because I’m tired of seeing production clusters running bloated images that act as a buffet for bad actors. You’re currently facing a binary choice: continue to ship heavy, "convenient" images that make debugging easy but security impossible, or embrace the friction of minimal, hardened artifacts that keep you out of the headlines. The contenders Most data engineers in my circles land on one of three paths when containerizing their PySpark or Pandas workloads. First, there’s the "Standard Distro" approach. This is FROM python:3.11-slim or FROM ubuntu:22.04 . It’s familiar, it has apt , and you can pip install anything without breaking a sweat. Second, we have the "Distroless" camp. This is Google’s gcr.io/distroless/python3 . It contains absolutely nothing but your app and its runtime dependencies. No shell, no package manager, no local tools. Third, there is the "Alpine/Musl" route. This is FROM python:3.11-alpine . It’s tiny, but it swaps the standard glibc for musl, which is a recipe for disaster if your data science libraries rely on C-extensions. Photo by CHUTTERSNAP on Unsplash The hidden cost of "easy" images If you’re using python:3.11-

“Store the data” is only the beginning of the problem. The difficult questions usually come afterward: What structure does this data actually have? Which fields are missing or inconsistent? Which values are invalid? Which changes are safe to apply automatically? What exactly changed after a repair? Can the system prove that its storage and indexes are still consistent? I built Atlas to answer those questions inside the database engine itself. Atlas is a zero-dependency embedded database for semi-structured data. It stores records, builds a full-text search index, infers schema, analyzes data quality, proposes safe repairs, preserves uncertain records, and records an audit trail of applied changes. It does not use SQLite or SQL. It is not intended to replace SQLite for relational workloads. Instead, Atlas focuses on a gap that is usually handled by external scripts and tools: Data inspection, diagnosis, and safe repair as first-class database capabilities. That is the problem Atlas was built to solve. Why data quality belongs inside the database engine Most databases are very good at storing and retrieving data. That is necessary, but real-world data work rarely stops there.** Operational records, imported JSON, CSV files, event payloads, and semi-structured documents often arrive with problems: { "id" : "T-1" , "title" : " Connection timeout " , "priority" : "HIGH" } { "id" : "T-1" , "title" : "connection timeout" , "priority" : "high" } { "id" : "T-2" , "title" : "Unicode café search" , "priority" : null } These records contain several potential issues: Duplicate logical identifiers Leading or trailing whitespace Inconsistent capitalization Null-like values Missing fields Mixed data types Malformed email addresses Different date formats Inconsistent structures across records A storage engine can preserve these values perfectly while still leaving the data difficult to understand and use. The usual response is to add external tools: A schema profiler A data-quality

A probabilistic model can describe more than the data you observe. It can also include hidden variables that capture structure you cannot observe directly. But defining that model is only the beginning. Once an observation x is available, the practical question changes: Given this x , what does the model imply about the hidden variable z ? That is the central problem of Posterior Inference . The notation is compact, but the computation is not always easy. High-dimensional latent spaces, complex posterior distributions, and interactions among hidden variables can make both the posterior itself and expectations under that posterior difficult to compute. Start with the Joint Distribution Suppose a probabilistic model contains an observed variable x and a hidden or latent variable z . The model does not treat them as unrelated quantities. Instead, it represents their probabilistic relationship through a Joint Distribution : p ( z , x ) This joint distribution describes how the observed data and the hidden variable fit together inside a single probability structure. Once x is observed, however, the question becomes conditional. We are no longer asking only how x and z relate in general. We want to know how the possible values of z are distributed given the particular observation x . That conditional distribution is the posterior. Posterior Distribution: Conditioning on Observed Data The Posterior Distribution is p ( z ∣ x ) = p ( x ) p ( z , x ) ​ The numerator p ( z , x ) contains the probabilistic relationship between the latent variable and the observation. The denominator p ( x ) normalizes those values so that the result becomes a conditional probability distribution over z . The distinction is important: The joint distribution p ( z , x ) describes the probability structure of the model. The posterior distribution p ( z ∣ x ) tells us what that structure implies about z after x has been observed. In that sense, the posterior connects the model with actual data. Pos

Hey Everyone! At Major League Hacking (MLH), our mission is to empower student developers worldwide...

The build process for iOS applications involves multiple technical stages, including source code compilation, resource packaging, code signing, and IPA generation. Xcode is the first choice for most iOS developers, but build tools are not limited to Xcode alone; choosing the right tool for different development scenarios can significantly improve efficiency. xcodebuild: The Command-Line Version of Xcode xcodebuild is a command-line build tool bundled with Xcode that compiles and packages without opening Xcode. Common commands include: xcodebuild build to build the project, xcodebuild archive to create an Archive, and xcodebuild -exportArchive to export an IPA. xcodebuild is suitable for integration into CI/CD. CI/CD platforms such as Jenkins, GitHub Actions, and GitLab CI can invoke xcodebuild to perform automated builds. Its downside is that there are many parameters, with over a dozen common parameter combinations, requiring time for initial configuration. Moreover, xcodebuild depends on the Xcode environment and can only be used when Xcode is installed on a Mac. Fastlane: An Automated Build Tool Fastlane, written in Ruby, is an automation toolchain built on top of xcodebuild. It defines the workflows for building, testing, signing, and releasing through a Fastfile configuration file. For instance, lane :release defines a release pipeline that executes operations such as incrementing the version number, compiling, packaging, and uploading to TestFlight in sequence. Fastlane's match feature manages certificates and provisioning profiles, solving the problem of certificate synchronization in team collaboration. gym encapsulates the complex parameters of xcodebuild, allowing an IPA to be generated with a single command. Fastlane also has a rich plugin ecosystem covering push notifications, screenshots, and metadata management. Project Management with CocoaPods and XcodeGen CocoaPods handles the integration of third-party dependencies. Declare the dependent libraries

submitted by /u/ThereWas [link] [留言]