taharvey

Autonomous systems startup, after assembling one of the largest teams in differentiable computing, demonstrates super-fast differentiable AI training running two orders of magnitude faster than standard frameworks.

Collaborating with the Swift community and Apple compiler team, they are using the Swift language as a strongly typed embedded language for a generative autonomous platform using ahead of time compilation of graph neural nets. They are focus is fusing systems programming and AI support in a single native high performance language, to enable typed heterogeneous inference and training. The compiler development is open sourced as part of the standard Swift package. Try it yourself at swift.org.

C is already a subset. It's basically one step above assembly.

Not sure I'd take advice on UI/UX behavior from someone who professes to not leave a terminal window... 35 years after better things came along. I know I live back when terminals were all we had. Boy were we happy when that wasn't true anymore.

No matter how much you like typing everything in a terminal, it is the least efficient environment for file system navigation. It lists file systems in 1-D where you...have....to...type...out...paths and cache the organization in your own memory. The poor UX of the terminal leads to lot of bad habits, like shortening names to acronyms, reducing hierarchy for typing convenience, and dumping files an unorganized mess (looking at you usr/local/bin). GUI file navigation is 2-D or even 3-D organizations of files that together with spotlight indexing I know I outrun terminal navigators by 10X in a real-world file system.

On a Mac invisible files aren't important for even a "pro" user... except for occasional developer needs. It worth saying a feature like this doesn't come without cost.

Progressive disclosure and a bullet proof user environment are core user concepts on MacOS. In MacOS a user can rearrange nearly every file visable to them, and never break anything.

Windows and Linux clutter up the users environment with files that literally no one will ever care about (1000 library modules and asset files for a binary application?). And yet they are less flexible to user choice. Move application out of the Application folder... boom! Pathing all breaks. Do the same on MacOS no problem.

Exactly.

It's not just Google. Adobe or any other company installing always running updaters... is just wrong.

This is actually the core failure of the Linux approach and why they year of the Linux desktop never occurred. Because there is no 1-true approach, developers must support too fragmented of an ecosystem, thus Linux becomes too big a lift to target for software titles.

Similarly the mass market of users care less about pimping their ride (so to speak), as getting their work done. Thus little is gained by rearranging your display or initialization subsystem.

One of the key things I find attractive about MacOS is that design is more than skin deep or an ad-hoc assemblage loosely related libraries. Meaning that visual design, architectural design, APIs, and even silicon co-designed makes for better systems.

Interesting milestone, worth reflecting on the broader failures of OSS.

Open source user-facing software like Gimp, Openoffice & inkscape were supposed to be the wave of the future that would eclipse their commercial counterparts over the next decade.

But OSS developers turned out to be daft to UI/UX concerns and lacked user-centric empathy to make software that would ever really matter in the marketplace.

Meanwhile the OSS marketplace that did takeoff in stunning ways were developer frameworks, libraries and building blocks (ie. everything on Github). Which developers then used to build the far more insidious world of SaaS. Where couldn't even own the software at any price, and more dastardly... you can't own your data.

Your statement is de-latched from facts. What are you smoking.. seriously?

Who is following in the footsteps of strong-man totalitarian practices? Trump. You can not name any democrat that would fit this description.

Who uses propaganda incessantly. Trump. 25,000 provably false statement in 4 years. Fox news, owned by a Trump ally , maintained a stead stream of provably false pro-Trump right-wing propaganda. Does any democrat or other politician in US history is have such a record? None.

Who is trying on undermining government and shove an agenda down our throats. Trump and the Republicans, who despite have little popular support for many of their policies (by independent polling) use gerrymandering to twist the vote, actively obstruct the government from governing, jamb right-wing extremist justices into court positions. Do democrats ever do this? Almost never.

I grew up in the New York area, like other new yorker's who voted 90% for Biden, we all know something you don't. We've seen his ridiculous antics for decades. He has been a perpetual lier, tax-evader, serial failed business man, narcissistic self-promoter, and con-man. Heck he's been a democrat... but I guess that was back when he needed all those abortions for his mistresses.

In the end, he like much of his elections team, will be put in jail for his crimes. But because he knows he's done a lot of illegal shit, he will first pardon himself... just watch.

This.

There are in fact many parties in the USA. But unfortunately the USA is still using an early alpha release voting system that was invented in the 1700s before voting theory had been even understood.

The result of a majority win voting system is that it only legitimizes 2 parties in practice. This worked 'ok' so long as the 2 parties acted in good faith.

However the last 20-30 years the Republican party got twisted into a movement to undermine government, enrich themselves, and narrowly focus on a couple of right-wing Christian interests to distract a populist base. They've maintained their relevance by turning Fox news and other right-wing owned outlets into effectually state-run propaganda machines. Leaving only the Democrats trying to govern with the Republicans trying to undermine and obstruct that very government.

The only way out of the USA's problems is to have a modern preference voting method, or in the long term the country may be doom to fail.

Not sure they are bad people per se... but where do you draw the line?

Sure Hitler improved the German economy, does that make it defensible to support him?

This is the fundamental question in nationalist movements that are driven by ideologies, tribalism, and cult of personalities... instead of real facts backed up by science and data.

Given that provably almost nothing Trump ever says is even true, how can these people know he is the best person to govern? If there are no facts, it is just beliefs... and that is incredibly dangerous.

Totally agreed. The biggest problem in the political discussion is false equivalency.

If one side doesn't believe in truth, facts and science, and the other side defends them as fundamental to everything... than those are not equivalent positions.

This has been largely a one-sided war on decency. Don't kill the messenger.

I would say this is the fundamental reason to vote. What we saw in this countries current divisions is:

REPUBLICANS: voting for ideology over everything

EVERYONE ELSE: voting for democracy and stability over ideology.

Proves only gullibility has no racial boundaries.

Well said. Let startups be visionary, the government should be boring and centrist most of the time.

If everything is going well and on track in the government, there shouldn't be any news.The president of the united states shouldn't be the center of attention.

Figma approaches design from an investors point of view.

Like most other web-SaaS tools, they aren't browser based because its better for the user. They sacrifice speed, native functionality, and usability for owning via server-side control over your wallet on a subscription plan.

The startup market in no-longer customer driven. It is investor thesis driven.

Essentially Swift is in Lattner's words "Syntactic sugar for LLVM"... meaning it was designed from a compilers point of view to provide an ontology for code that a compiler can analyze, interpret, optimize, and enable deeper functionality. Swift backed that ontology with a functional type system that forms a set proofs of the relationships and meaning of your code.

If you take a language like C++, the "atoms" of the code like a Float32, are just hard coded intrinsics in the compiler. As such, they have no ontological meaning in relationship to a Float16, an Int32, or an Array of Strings. In Swift, a float is built from a set of proofs as equatable, hashable, Numeric, FloatingPointNumber, and etc. As related to Julia or Python, a static language built around these proofs, enable compiler's to provide "co-pilot" development assistance, guarantees at runtime, code validation.

Why is this important? With deeper knowledge, a compiler can optimize things in ways that weren't previously possible, extract graphs, and automate code execution in heterogeneous computing evironments.

I would encourage you to look deeper.

1. We've moved our company code base from tight C/C++ code to Swift. It is just as fast, with higher level syntax. In some cases faster. It has native SIMD types without external libraries too. Moreover, the Swift group has been focusing on correctness over performance to date. The goal has always been, that its deeply typed design can enable optimizations not even possible in c/c++.

2. Several of the founding Rust team moved to the Swift dev team years ago. As of Swift 5, the memory model supports the Rust-like borrowing. One could say Swift at this point is a complete superset of Rust. But, more importantly Swift favors a functional style of value type operations... which are inherently memory safe, and have no concurrency side effects in the first place. Value types together with Swift's very easy to use Dispatch concurrency library work for most use cases... it is viewed that "borrowing" is only a special purpose opt-in feature.

3. Swift is pragmatic. It is functional in its type system, value type operation, and no side-effect philosophy. But it is multi-paradigm, flexible, and designed for the real-world problems that reflect real programming needs... where as Haskell is arguably an academic curiosity and extremely unlikely to become a mainstream general purpose language.

What part of Swift being as fast as C++, as safe as Rust, and with the functional type system of Haskell (but actually useful in the real word) is unappealing?

Actually this started before Lattner. Richard Wei kicked this off with his DLVM thesis.

Either way, Swift's functional design around a type system has some compiler implications towards solving larger problems that Julia probably will struggle with as it moves forward beyond the goal of just being a faster Python.

The guys in our group giggle at Hacker News. The only time they ever even hear about Julia, is when a Swift article shows up here... then all the Julia nerds come out of the woodwork.

Guessing the opposite rarely happens.

I'm not conflating. Just like Julia, Swift can JIT... after all both are built on top of the inventor of Swift's LLVM compilation environment.

That is not what I'm talking about. Nor am I talking about dynamic dispatch. Swift supports 4 different dispatch models from static to dynamic, depending on how the compiler optimizes.

What I'm talking about is a static type system. From Julia's documentation: "dynamic type systems, where nothing is known about types until run time".

What is fascinating, is ML/AI developers develop deep infrastructure to support ontologies for their target problems, but then forget to adopt the same for their code tooling. You can go though a series of proofs to demonstrate that you can't extract intent from a language that doesn't enforce it. And what is possible in a language's future can be expressed by how much intent can be extracted.

Like Julia, Swifts scientific computing ecosystem is still evolving. But keep in mind that Swift can call Python, C, objC & C++ directly, works in Jupyter notebooks, has already large general purpose open source library ecosystem.

You apparently aren't familiar with Swift at all. I'd recommend exploring more before answering.

Swift had Linux support since it open sourced 4 years ago. IBM, AWS, Google all have very performant server-side swift packages for manner of things from servers to protocols. Our company is using Swift for a Linux-only embedded environments.

If you think the future is dynamic, you're not regressing the past, or the trajectory of the future. Dynamic languages keep a compiler from understanding the code.

Compilers are just code optimization heuristics - like AI for developers. If you make a language and compiler that has a strong ontology for the intent of code (a type system), it can break code down into functional proofs, then understand how to optimize it and in ways that aren't possible in a dynamic language that breaks the chain of intent.

Julia is still pretty niche at this point, and just recently got tools as fundamental as a debugger.

I suspect his comments are about the vision for the whole solution and environment, not just auto-diff, which is just a piece.

Auto-diff extends back 40 years. But the relative obscurity of its usage is that it is a "add-on", meta-programming step, or/and a limited sub-set of a language.

The Swift approach of 1st class compiler support is fairly unique. But also supports a future view of computing. If many problems can be solved by differentiable programming, not just the typical but somewhat niche NN/ML problems, then it needs to built into the whole language, not a sub-set.

But more importantly the future requirements, and death of Moore's Law means a fast, deeply statically analyzable language will be required to make the most of a heterogeneous computing environment.

Or... as Jeremy Howard said it, having a real compiler with a strongly typed language is "mind blowing" after working in Python.

A compiler isn't in your way, with modern JIT compilation and a language with an actual type system, its actually an productivity assistant. Shouldn't AI researchers have automation too?

In his lecture, he specifically said he interviewed both the Swift and Julia teams and got a view inside what happening at Google... and the the Swift teams work, development, and vision was well beyond what the Julia team had even envisioned.

Swift is:

  1) A fast general purpose systems language (like C++)

  2) With high level semantics and usability (like Python)

  3) With type system from functional programming (like Haskel)

  4) With concurrent memory model (like Rust)

  5) That uses compile-time analysis for static guarantees

  6) That runs everywhere from CLI scripting to ML to App devlopment

  7) With a huge user base (millions of devs)

  8) And two large corporate backers (Apple & Google)

  9) The developers include the originators of Rust and the developers of LLVM & Clang.

Thats a killer list. And Julia only addresses 1 & 2.

It is further believed by the core group at Google and Fast.ai (and history) that the future must be a static type checked language to scale beyond the script-level experimentation of python to large application development where the lines between ML, application, and system development will blur. Its will also be critical to next-gen performance breakthroughs and heterogeneous computing. And the type system provides a fully hackable language for fast experimentation.

Also Richard Wei, not Lattner, I believe initiated the project with his DLVM thesis... specifically because Swift was such a good fit and is so hackable.

Ok, I'm going to take this one.

First, are you claiming that weather scientists and forecasters are part of a vast global conspiracy? Seriously? These guys aren't even climate scientists, they are just building more accurate sensor networks and forecasting models. And if you look at the forecasting models running on todays supercomputers they are devastatingly accurate compared to 2 decades ago. So one can guess they are getting it more right, than wrong.

It think to biggest issue here is "normal" people don't understand math or stats.

I work with weather data sets in building simulation, which involves sensors and sensor fusion. First, there is no sensor that doesn't involve algorithms, statistics, or some sort of "data cleaning". Unless you are talking about a glass thermometer visually inspected... and if thats the only "data" you'll accept then we are talking serious luddite tendencies here.

All weather data needs cleaning. There are data drops than need interpolation, sensor stats checks to detect erroneous readings, multi-sensor fusion to make more accurate values. Get real.

While I get the concern, everybody's history here is backwards. Apple released Metal 2 YEARS before Vulkan. Why? Because OpenGL wasn't hacking it anymore and had become too asymmetric. Vulkan copied Metal, not the other way around.

I'm not sure they should have spun around and dropped Metal for Vulkan once it became available, or slow down the pace of progress til the rest of the market caught up. Doesn't make sense.

Also Apple is perhaps the largest GPU manufacturer in the world, with 200-250M GPUs shipped in 2017. That is 4-5X of Nvidia! Also Apple is investing highly in AI from tools to devices to GPUs, being able to customize may have tremendous value.

It is highly possible that Apple sees owning their interface stack as a means to keep their software-hardware warchest a couple years ahead of the competition. Which in mobile has been paying off of the last 5 years, as they constantly have crushed all others by 2-3X.

Your view of visualization is a limited world: windows and Max?

Honestly, because professionals don't use it.