Chris Lattner

> About 8 or 9 years. Awesome! There's another woodworker I follow (https://nondot.org/sabre/Woodworking.html) who is also a pretty good programmer ;). > Causing massive harm to other people because it might possibly make the number in one's own bank account slightly larger seems like pretty miserable behavior to me. I disagree with a ton of what PT says/does, but I respect how he always come about things in an original way--he's got his own model of the universe that he follows. From what I can tell he also is always learning, and willing to update his model when shown wrong. Most people just accept the model of the universe given to them by authorities.

Christ Lattner's (the Swift guy) homepage: http://nondot.org/sabre/ One of my personal favorite shite pages with great content.

I haven't followed the news about Chris Lattner. For those who like me who haven't seen that he's in Google now: http://nondot.org/sabre/ "I worked for Apple from July 2005 to January 2017, holding a number of different positions over the years" "This included managing the Developer Tools department, which was responsible for Swift Playgrounds for the iPad, Xcode, and Instruments, as well as compilers, debuggers, and related tools. In early 2017, I briefly ran the Tesla Autopilot team. We built a lot of great things, but Tesla wasn't the right fit for me." Joined "Google Brain" in August 2017. https://techcrunch.com/2017/08/14/swift-creator-chris-lattner-joins-go…

The only quote I can find about swift and Light Table is this: > The Xcode Playgrounds feature and REPL were a personal passion of mine, to make programming more interactive and approachable. The Xcode and LLDB teams have done a phenomenal job turning crazy ideas into something truly great. Playgrounds were heavily influenced by Bret Victor's ideas, by Light Table and by many other interactive systems. From: http://nondot.org/sabre/ And that just mentions "Playgrounds", which seems to be some sort of editor application written in Swift. It did not inspire Swift itself. And also, Swift hardly "changed the whole industry", as far as I know.

I read Chris Lattner's online CV [1] (probably via HN), he of Apple/LLVM/Tesla fame and a technical engineer I regard rather highly. It's an excellent example of story-driven resumes. [1] http://nondot.org/sabre/Resume.html

Maybe. Or maybe not. The data I presented is insufficient. Kotlin initial commit 8 Nov 2010 - https://github.com/JetBrains/kotlin/commit/369b1974782b821e44b7aa6cd68… . Note that this does not mean it's the first work done on the project, only the first commit. http://www.nondot.org/sabre/ says "I started work on the Swift Programming Language (wikipedia) in July of 2010. I implemented much of the basic language structure, with only a few people knowing of its existence. A few other (amazing) people started contributing in earnest late in 2011, and it became a major focus for the Apple Developer Tools group in July 2013." In any case, it's clear that neither was influenced by the other, at least during initial development.

> Swift's designers even cited Rust as an influence. Specifically, http://nondot.org/sabre/ > Of course, it also greatly benefited from the > experiences hard-won by many other languages in the > field, drawing ideas from Objective-C, Rust, Haskell, > Ruby, Python, C#, CLU, and far too many others to list.

"I started work on the Swift Programming Language (wikipedia) in July of 2010. I implemented much of the basic language structure, with only a few people knowing of its existence. A few other (amazing) people started contributing in earnest late in 2011, and it became a major focus for the Apple Developer Tools group in July 2013. The Swift language is the product of tireless effort from a team of language experts, documentation gurus, compiler optimization ninjas, and an incredibly important internal dogfooding group who provided feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list." - Chris Lattner, http://nondot.org/sabre/

Another great resource for OS development information is OSRC: The Operating Systems Resource Center hosted by Chris Lattner (of LLVM fame): http://www.nondot.org/sabre/os/articles

If you go down this path, and I highly recommend every coder gives writing their own OS a go, be sure to bookmark: http://nondot.org/sabre/os/articles

It's worth noting that Apple's chief compiler architect is Chris Lattner, who started LLVM as part of his Master's Thesis. I think "playing nice" has more to do with hiring the founder and lead of the project than with any Apple policy. Although, yes, I found it odd that Gruber implied it was Apple's technology. edit: Lattner's page with publications and projects: http://www.nondot.org/sabre/

I read the transcript but at the end I wished they had touched upon some comparisons of Swift with C# and the open sourcing of the .NET platform by Microsoft. Craig's/Apple's comments on that would be interesting now that C# and .NET are also becoming truly cross platform (unlike the Mono platform that lagged behind), which is something Swift also aims to be, although we don't know what frameworks and libraries from Apple would or could become cross platform. Also, C# and .NET have had longer than a decade to become what they are today. It would've been interesting to hear more details on what lessons and developments from the last decade and a half helped accelerate the development of Swift (not just from C#.NET, but also other languages and programming paradigms). Chris Lattner's page [0] just mentions a one liner saying "...it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list." A geeky interview with Chris Lattner might be the next thing to look forward to on this topic. :) [0]: http://nondot.org/sabre/

I think there is something special about physical creativity that scratches a certain part of your even if you have a very fulfilling day-job. "Even" Chris Lattner (of LLVM and Swift fame) which I as an outsider at least would say have a fulfilling job dabbles in the occasional woodworking: https://nondot.org/sabre/Woodworking.html

I had no idea this was a thing, but I did notice Chris Lattner (of LLVM) is a woodworker. https://nondot.org/sabre/Woodworking.html

Then you should appreciate Chris Lattner's Homepage http://nondot.org/sabre/

I added a few sentences about that to the post: > In the case of our example, the program actually compares such an “unobservable” bit pattern with a constant, so the compiler constant-folds the result to whatever it pleases. Because the value is allowed to be “unstable”, the compiler does not have to make a “consistent choice” for the two comparisons, which would make such optimizations much less applicable. So, one time we “look” at x the compiler can pretend it is at least 150, and then when we look at it again it is at most 120, even though x did not change. Also see http://nondot.org/sabre/LLVMNotes/UndefinedValue.txt.

http://nondot.org/sabre/Resume.html "Swift for TensorFlow rethinks machine learning development ... I imagined, advocated for, coded the initial prototype and many of the subsystems after that; recruited, hired and trained an exceptional engineering team; we drove it to an open source launch and are continuing to build out and iterate on infrastructure."

> I wonder if LLVM has a code of conduct? It does indeed. It was mostly non-controversial, except for [AFAIK] one notable departure, de Espindola [1]. Lattner's response [2]. > ... new open source CoC whose mere existence is a violation of itself. I can't tell if you're just being silly or if you're referring to an actual contradiction related to relicensing and/or the CoC. [1] http://lists.llvm.org/pipermail/llvm-dev/2018-May/122922.html [2] http://nondot.org/sabre/2018-05-02-Rafael.html

> I don't see any Python influence in Go Well, in Google's own words[1]: "Go attempts to combine the development speed of working in a dynamic language like Python with the performance and safety of a compiled language like C or C++". Some go datastructures are very python-like. Coming from a big Python shop, it's unsurprising. Chris Lattner mentions Python[2] as an influence among others. Swift's lists and dicts are very python-like. The way python deals with datastructures is one of its strong points, and it's clearly more modern than anything C-like. Both Go and Swift are more restrictive than Python in many ways, mostly for performance reasons since they are built for specific needs, but the influence is there and openly admitted. [1] https://techcrunch.com/2009/11/10/google-go-language/ [2] http://nondot.org/sabre/

http://nondot.org/sabre/ "I lead and am the original author of the LLVM Compiler Infrastructure, an open source umbrella project that includes all sorts of toolchain related technology: compilers, debuggers, JIT systems, optimizers, static analysis systems, etc. I started both LLVM and Clang and am still the individual with the most commits."

I always liked that Chris Lattner pubicly acknowledged Light Table as the inspiration for SWIFT Playgrounds: http://www.nondot.org/sabre/ Now, of course their new project is Eve

>> "tl;dr: B3 will replace LLVM in the FTL JIT of webkit. LLVM isn't performing fast enough for JIT mainly because it's so memory hungry and misses optimisations that depend on javascript semantics. They got an around 5x compile time reduction and from 0% up to around 10% performance boost in general." [1] Is this a knock on LLVM then? I wonder then specifically if this brings to light any concerns over Swift (another dynamic language, and was created by the same person who created LLVM as well). [2] Seems weird that the original creator of LLVM was able to make a dynamic language such as Swift - without any problems. [1] https://news.ycombinator.com/item?id=11105231 [2] http://nondot.org/sabre/

Hearing one of the core engineers from the LLVM compiler team speak at some length about their aims and approach to Swift, it was cleat that they had reflected long and hard on the approaches of many other languages. This engineer had very informed and nuanced views on the strengths and weaknesses of pretty much any other language you asked about. I'm sure Scala was on this list, also "Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list" — http://www.nondot.org/sabre/

Swift started private development in July 2010.[1] So not quite five years, but pretty close. 1: http://nondot.org/sabre/

Your timeline is way off. llvm-gcc was introduced with Xcode 3.1, and clang/llvm in xcode 3.2. It targeted 10.5. This was well prior to 2011 , and seeded well before it was released. Again, you don't have to believe me, Chris's resume shows this: http://nondot.org/sabre/Resume.html#Apple "In this time period, my group expanded use of LLVM within Apple, supported new clients, built new features, and extended LLVM in many ways. We shipped llvm-gcc 4.2 in the Xcode 3.1 and major improvements for it in the Xcode 3.1.1 release." That time period was in 2006-2008. Apple made a decision that it was going to move if it could meet certain performance goals in the 2006/2007 time frame. GPLv3 was not released until June of 2007. In any case, this argument is pointless, you can just ask Chris why they moved.

Both the Light Table team (http://www.lighttable.com/2014/06/10/light-table-and-apples-swift/) and the Apple Swift lead (Playgrounds feature: http://nondot.org/sabre/) have explicictly cited Bret as an important influence — his ideas are certainly not going to waste.

Here is some information about TCE in LLVM from the lead developer: http://nondot.org/sabre/LLVMNotes/GuaranteedEfficientTailCalls.txt

From Chris Lattners resume(http://nondot.org/sabre/Resume.html): "Apple shipped the Mac OS X 10.8 and iOS 6 releases, and they were built virtually entirely with Clang - llvm-gcc is obsolete." Another interesting thing: "We invested major effort into compiler implementation and tuning for the custom Apple CPU design known as the "Apple A6". The exceptional CPU performance of the iPhone 5 was a result of a joint effort between the Apple silicon and LLVM teams."

To be clear, the compiler is not forbidden from optimizing `always_returns_true` to unconditionally return true. After all, undefined behavior can cause anything to happen, and that includes returning true. Normally LLVM would perform exactly that optimization. But in this case `always_returns_true` is inlined first, so it becomes something like `undef < 150 || undef > 120`; LLVM propagates the `undef` outward through the expression until the whole condition is `undef`, and then it arbitrarily picks that the condition should be false. But `always_returns_true` is not an example of how this particular undefined behavior can be useful as an optimization, merely an example of how it can be dangerous. For some examples of how it can be useful: - Document describing the origins of `undef` in LLVM: http://nondot.org/sabre/LLVMNotes/UndefinedValue.txt Basically, it helps to be able to replace "cond ? some_value : undef" with "some_value", especially when the code has been transformed to SSA form. - Some architectures literally have a 257th possible value, like Itanium [1] [2]. On Itanium, every register can be set to "Not a Thing", i.e. uninitialized, and the CPU will trap if you try to store such a value to memory. Ironically, NaT was created in order to make the CPU's behavior more defined in a certain case, or at least more predictable... argh, I'm too tired to explain it properly; look at section 2.3.1 of [2] for a somewhat confusing explanation. [1]…

Yes he was, because it's a software problem and he's proven himself to be world class at solving software problems. Here is some more evidence from his resume. "When I joined Tesla, it was in the midst of a hardware transition from "Hardware 1" Autopilot (based primarily on MobileEye for vision processing) to "Hardware 2", which uses an in-house designed TeslaVision stack. The team was facing many tough challenges given the nature of the transition. My primary contributions over these fast five months were: We evolved Autopilot for HW2 from its first early release (which had few capabilities and was limited to 45mph on highways) to effectively parity with HW1, and surpassing it in some ways (e.g. silky smooth control). This required building and shipping numerous features for HW2, including: support for local roads, Parallel Autopark, High Speed Autosteer, Summon, Lane Departure Warning, Automatic Lane Change, Low Speed AEB, Full Speed Autosteer, Pedal Misapplication Mitigation, Auto High Beams, Side Collision Avoidance, Full Speed AEB, Perpendicular Autopark, and 'silky smooth' performance. This was done by shipping a total of 7 major feature releases, as well as numerous minor releases to support factory, service, and other narrow markets. One of Tesla's huge advantages in the autonomous driving space is that it has tens of thousands of cars already on the road. We built infrastructure to take advantage of this, allowing the collection of image and video data from this…