Entries tagged with brian beckman - Channel 9

Brian Beckman Does Higher Algebra with Visual Basic

funkyonex — Wed, 19 Dec 2007 16:19:29 GMT

In this interview, Brian Beckman, Principal Developer (currently working with Erik Meijer), attempts to teach me higher algebra using Visual Basic, generics, and operator overloading. Brian is a wonderful person and brilliant physicist and we have a lot of fun with vectors and matrices and VB. I actually think I understood some of what Brian showed me ;).

Visual Basic is a great language for mathematics as well as all kinds of other applications. Brian makes the point that he has fun coding in VB because of its intuitive style and how easy it is to be immediately productive. Check out Brian's blog post on the VB Team blog! And for all you abstract algebra aficionados, here's the code to play with.

Enjoy,
-Beth Massi, VS Community

Expert to Expert: Brian Beckman and Sam Druker - Deep Entity Framework

Charles — Wed, 05 Dec 2007 16:53:29 GMT

You've seen a few conversations on Channel 9 about Microsoft's Brian Beckman recently had a deep technical chat with Sam Druker about the Entity Framework data model and related technologies.

Sam is GM of the Data Programmability Group at Microsoft and also happens to be Brian's boss and former programming colleague. Sam's a very technically-inclined executive... He has to be considering he's a leader in the Microsoft group that makes SQL and the plethora of data-related platform technologies, not to mention that he has to manage the likes of Erik Meijer and Brian Beckman.

This interview is great for two simple reasons. The first reason is that, well, it's a great (and deep, including whiteboarding) conversation between experts that spans many technologies related to SQL and the Entity Framework.

The second reason is that this is the first in a series of interviews on Channel 9 that involve experts in one domain (or many domains, like Brian) who interview other experts in another domain that is not well understood by the interviewer (so, in this case, for example, the venerable Brian Beckman really does not ask any questions that he already knows the answer to. Brian is not an expert in EF, but possesses a very unique perspective in this case given his mathematical tendencies and expert level understanding of things like set theory...). Yours truly, Charles, takes part in the conversation of course, but I'm mainly a camera guy who throws in a random question once and a while. Brian drives this interview.

Like you, I'm in the audience and learning from people who truly understand the deepest levels of a given platform technology. Again, Brian Beckman conducts this interview and I think this is a trend you are going to really enjoy.

Thank you, Brian and Sam!

You'll see more of this class of interview in the future on Channel 9.

Learn. Enjoy.

Brian Beckman: Don't fear the Monads

Charles — Thu, 22 Nov 2007 18:28:02 GMT

Functional programming is increasing in popularity these days given the inherent problems with shared mutable state that is rife in the imperative world. As we march on to a world of multi and many-core chipsets, software engineering must evolve to better equip software engineers with the tools to exploit the vast power of multiple core processors as it won't come for free as it did in the recent past which was predictably based on Moore's law.

Of course, learning new ways to think about programming semantics and code patterns are not always straight forward. For example, most imperative programmers (which include most of us who build software for a living...) are somewhat perplexed by the notion of functions as first class data structures that can be combined to create powerful and composable systems. Languages like Haskell are pure functional languages and require programmers to think in a different way, often in a precise mathematical fashion where composing and chaining functions is "the Way".

Dr. monads in an easy to understand way: a technical conversation at the whiteboard with yours truly for Channel 9.

This video interview is the result of Brian's idea that he can in fact remove the fear of monads from anybody who pays attention to his explanation. Of course, you can't just cover monads in a vacuum (category theory is not really addressed here) so the context is functional programming (Brian covers functions and composable functional structures (function chains) and of course monoids and then monads).

Tune in. There's a lot to learn here and only Brian can make monads easy to understand for the rest of us!

Happy Thanksgiving to all the US Niners out there.

Enjoy.

Brian Beckman: A Brief History of Computing

Charles — Fri, 31 Aug 2007 18:07:18 GMT

I recently got the chance to sit down with Brian Beckman, physicist, programmer and Apollo Soyuz international space mission incorporated a programmable calculator, the HP-65, to calculate precise course corrections for the rendezvous and linking of Apollo and Soyuz space crafts? A calculator!! Indeed, programmable calculators are the predecessors of today's computers. But what came before the hand-held computing titans of the 70s? What was the first computer?

Brian has quite a collection of computing devices in his office, some of which, as expected, predate digital devices. We get a look at these and learn about their place in history.

Of course, Brian is a software developer with uncanny capability for designing accurate simulations (remember the C9 Screencast to dig into what he did, so look for this showing up soon!

As always, it was a pleasure to converse with Brian and learn about how computers got to where they are today. It's a long interview, so get comfortable, relax, and learn from a master.

Brian Beckman: The Physics in Games - Real-Time Simulation Explained

Charles — Sat, 09 Jun 2007 01:53:37 GMT

Ever find yourself wondering about the math behind your favorite simulation game? Did you know that the motion physics of a car are much more complicated than the those of an airplane?

Brian Beckman, physicist, programmer and Channel 9 celebrity (he's been on C9 a few times...), sure does. Besides spending time innovating programming languages and tools, Brian spends time working on the mathematics behind real-time physics simulation. Most recently, he worked on the math behind the tire physics of the popular racing game Forza.

Simulation, by definition, needs to be accurate. Otherwise, well, it's not simulating reality, really, which is of course the idea of simulation. Games like Forza in fact simulate real physics of racing in a predictable and highly mathematically precise manner. That's exactly why Forza is a real-time automobile racing simulation game.

The past, present and future of computer simulation of real-time physical events, or simply computer-based simulations that involve highly accurate representations of things moving/changing in space and time that are precisely affected by multiple variables like wind, rain, gravity, mud, oil, planets, waves, etc are very fascinating topics for gamers(many may not realize this explicitly, but they sure experience it!), mathematicians, programmers and physicists alike. Heck, any body who thinks about the thinking behind things that they experience in a simulated environment should watch/listen to this interview (available in podcast form as well as video).

Towards the end of this conversation, Brian mentions Rigs of Rods and Plasma Pong. Check out the Rigs of Rods simulation demo at 00:58:11!

Our sister site, Channel 10, has a great Forza piece.

Tune in. Learn (alot).

Anders Hejlsberg, Herb Sutter, Erik Meijer, Brian Beckman: Software Composability and the Future of

Charles — Fri, 19 Jan 2007 04:32:00 GMT

How will imperative programming languages evolve to suit the needs of developers in the age of Concurrency and Composability? What role can programming languages play in enabling true composability? What are the implications of LINQ on the furture of managed (CLS-based) and unmanaged(C++) languages? How will our imperative languages (static) become more functional (dynamic) in nature while preserving their static "experience" for developers?

Answers to these questions and much more are to be found in this interview with some of Microsoft's leading language designers and programming thought leaders: Anders Hejlsberg, Technical Fellow and Chief Architect of C#, Herb Sutter, Architect in the C++ language design group, Erik Meijer, Architect in both VB.Net and C# language design and programming language guru, and Brian Beckman, physicist and programming language architect working on VB.Net.

This is a great conversation with some of the industry's most influential programming language designers. Tune in. You may be surprised by what you learn...

Brian Beckman: Monads, Monoids, and Mort

Charles — Tue, 29 Aug 2006 17:34:24 GMT

Brian Beckman is a fascinating individual. Ex-cosmologist, ex-military operating system and simulation developer (have you ever considered processes that move both forward and backward in time? Well, Brian and team at JPL created just that. He explains in this interview...). Brian was one of the first members of Microsoft Research and one of a group of physicists who joined Microsoft in the early 90s. At Microsoft he is a passionate advocate for Mort, the somewhat ambiguous class name for novice developers. In fact, he considers himself a mort (somewhat hard to believe, honestly, but we'll go along with it...). His team works on innovative incubation projects that turn into developer platform features (like LINQ, for example) and more. Tune in to this very interesting interview.

Brainbec's Weblog