Sam Stokes on Research in your life and studies : Electrical Engineering

F#: Using the Interactive Panel in VS 2010 Part 1

SoCal Sam — Wed, 01 Jul 2009 19:43:04 GMT

Use the Interactive Panel in VS 2010 to learn how to use F#. I have not included the code used in my examples, my guidance to you is to visit:

F# 1.9.6.16 Draft Language Specification,

start off with: “Making Data Simple” use the interactive panel to test the examples. Then work through the rest of the specification, as you do note down ideas that you have about how to use F#.

It’s pretty cool.

For the QuickStart viewers, my apologies for the latest of this video, I use MSN Videos and the system hasn’t been working well lately.

The video is also available for download, and easier viewing at the following link:

Coding Functionally

I should be able to get the rest of the talk posted over the next few days.

WTF#: Changing the curriculum on programming for scientists and engineers

SoCal Sam — Mon, 23 Mar 2009 18:39:34 GMT

Changing the curriculum for Physics Majors and Engineers, as we can see, the process to prepare people who might be engineers and scientists (except for the computer scientists) need to have some modifications. First of all, the process of training engineers and scientists appears to be modified, the computer scientist students need different approaches, they are building, deploying and maintaining tools. The current approach of attempting to combine engineering and scientists in the training of programming doesn’t help the computer scientists, they have to spend time learning languages like Java and C#, that could be better spent learning and using C++. Engineers, especially Computer Engineers have to spend time not learning the C Language used in controllers (although there are better languages), other engineers and scientists do not spend enough time learning how to implement solutions using high level languages.

Examination of the Mars Climate Orbiter clearly points to the factors that the aerospace engineers could have better served learning how to use tools to test the integration of the MCO, which would have been higher level languages.

System engineering, software engineering is still suffering from lack of focus, although lately there has been a stronger focus on the implementation of improved software engineering at schools like California State University, Fullerton and others. To me it is time that engineers feel comfortable with programming, programming that will solve their problems, not computer scientists.

Of course the problem for the schools is getting the students interested in the programs.

In later blogs, I will be covering the solution of simple physics problems using F#, but for now, I hope to hear from you about how to improve the teaching of programming for engineers and scientists.

Technorati Tags: Curriculum,WTF,science,engineering

WTF#: Could F# have saved the Mars Climate Orbiter?

SoCal Sam — Wed, 18 Mar 2009 00:05:20 GMT

The Mars Climate Orbiter likely failed due to one sensor passing data in the wrong units to the central processing units on the MCO. I have created a first cut demonstrating the use of the dimensional analysis capabilities in F#. It is a simple idea, but one that helps the engineers and scientists to get the issues on incorrect dimensions being used in software.

I am working on creating a simple Hohmann trajectory simulator, but it is a little more difficult than I thought so that will be coming out a little later in my blogging cycle.

Technorati Tags: dimensional analysis,game programming,games,XNA,engineering

WTF#: F#, and the Mars Climate Orbiter (MCO) crash in 1998

SoCal Sam — Mon, 09 Mar 2009 23:41:41 GMT

OMG: Slide Rules and F#, ‘sup with that? World of Twitter, Facebook, $300 computers running Windows 7, why would I even mention this arcane tool? F# and Slide Rules have something in common: Dimensional Analysis.

In F# you can use dimensional analysis to implement your programs. What does this mean? You can save $250,000,000 in wasted space craft for example. In 1999 the Mars Orbiter was doing a aerobraking maneuver to enter into Martian orbit, and when it started it’s rocket motor, it blasted itself out of orbit and crashed. The problem? Some of the code was in SI units (metric) and others were in the SAE (feet/pounds), somehow this passed critical code review. Nice job!

"People sometimes make errors," said Dr. Edward Weiler, NASA's Associate Administrator for Space Science. "The problem here was not the error, it was the failure of NASA's systems engineering, and the checks and balances in our processes to detect the error. That's why we lost the spacecraft."

Would F# as a high level language been able to solve this problem? Not knowing if the control law synthesis was done in a high level language or using assembly language or even hardware level programming. I am certain that with the many successes, as well as failures since the Mars Climate Orbiter’s crash, however the brief accident report that I can find easily on the web, has the quote from NASA ADVISORY COUNCIL March 16, 2000 (you have to scroll down a bit to see the article):

“There were four common themes from the failure investigations and studies: inadequate reviews; inadequately addressing risk management; inadequate testing, simulation, and V&V; and communications. In response to a question, Mr. Stephenson noted that more attention needs to be put on people—skills, training, etc. The Board made recommendations in four categories: people, process, execution, and technology. NASA tends to focus on process. People includes picking the right people (including the right leader), teamwork, communication, and adequate staffing and oversight. In the process area, the mission success criteria needs to be very clearly defined up front. Out of this derives the top level system requirements, etc. Other important aspects of the process are: systems engineering, verification and validation, risk assessment (e.g., fault tree analyses and probability risk assessment), the responsibility of the line organization, science involvement, operations (on the program from the start), and transitions (from development to operations).”

Wow, that sounds like a bunch of “blah, blah, blah” Improve process, the check is in the mail, and so forth. The problem was that there was a disconnect in the units used in programs and I haven’t found the article, but I am GUESSING that the rocket control law had been used in other systems successfully and wasn’t fully tested prior to launch. So fixing that would fix other problems as well. So maybe F# wouldn’t save the day, but for this blog article let’s assume the error in dimensions was the problem, see the article on the NASA site for a very brief explanation.

So what happened?

“Twice a day during the cruise to Mars, tiny thrusters on the spacecraft were fired briefly to counteract the effects of solar wind and other forces on the spinning of the flywheels. The spacecraft team in Colorado used English units called pound-seconds to describe the small forces….
That data was shipped via computer to JPL where the navigation team was expecting to receive the information in newton-seconds, a metric measure of force.”

How would F# have aided in preventing that problem? F# gives the developer the ability to assign units to variables. So it would be possible for a software architect to implement a system that would perform error checking of the results to make sure that the correct units were being used. In later articles I will be going over how to code and do the error handling.

Of course the bottom line is that the Mars Climate Orbiter crash was a monument to the dumb approach of faster, better, cheaper approach to spacecraft design, which is still causing problems inside of NASA these days. More in the next post. This is fun, well it would be if wasn’t so sad. :(

Technorati Tags: Mars Climate Orbiter,MCO,Simulations,Orbital Mechanics,F#,Functional Languages

WTF#: Syllabus for the rest of the students at a university, with a focus on Functional Programming

SoCal Sam — Sat, 21 Feb 2009 22:29:13 GMT

Information science and computer science pretty much control the programming classes and curriculum at the universities, colleges and trade schools. Most of the training is either to implement and manage systems or how to write programs and think about new problems and solutions. It is all good and needed, but what about the rest of the students?

In my thinking, I am just thinking about the students down the hall from computer science, the mechanical/aero/civil/electrical engineers. Much of what they do requires computations of some sort. Their research requires the use of computers, but is the approach currently recommended by the ACM and IEEE really fitting the bill?

Let’s say I am an electrical engineering student who is passionate about solving EMF problems related to the power curve utilization in the home. Here the power delivered by power companies is being polluted by the switching power supplies used by computers and battery chargers. That means that the AC power has all kinds of little spikes in it that changes the power distribution system in small ways.

Or I am a civil engineer that needs to do a hydrostatic simulation of drains in cities to determine the impact of gutter water on streams and ocean outlets. Or I am an aero that needs to do a simulation of a historical aircraft, like the airplane model that Einstein created while playing with his son Hans. Finally, what if I am a mechanical engineer that needs to do a dynamic stress analysis of a Ferrari automobile.

How do I as an engineering student get started with developing a program that doesn’t necessarily require MatLab or Mathematica? Or even be able to extend those excellent tools?

Java? C#? Visual Basic? Small Basic? Or a functional language that can do OOP when needed, like F#? What does a engineering student get motivated by? Having to write programs that conform to computer science protocols of code or problem domain? Or does the student need something that conforms more to their domain knowledge needs? What will these engineering students be doing with their domain knowledge when they go to work for the local utility firm, aerospace company, city permit desk or automotive design consultancy?

In the past functional languages such as FORTRAN, APL (A Programming Language), would be there to help with the early engineering student to help with the matrix calculations of matrixes larger than 4 by 4, and so forth. Today, the classes offered to these students may use a language like OCAML, which is the mother of F# where F# uses the light syntax of the OCAML language. These languages are prefect for the engineer, and F# is a play for both sides of the equation, in that it is both functional as well as object oriented.

In a well designed class for the engineers and scientists, the computer science students who also attend the class would have to sit through the way that the matrixes are used in math and engineering. But here is the trick: The engineers would be able to see the difference between the use of arrays and trees (something I always have problems with). So by making the modifications the students would be able to gain a more diverse way to use software to solve problems.

Technorati Tags: APL,FORTRAN,Martix Math,Binary Trees,Engineering

F#: Re-Thinking the syllabus for training engineers and scientists in programming

SoCal Sam — Fri, 20 Feb 2009 21:44:30 GMT

Well continuing my effort to bring F# to the Engineers, one of the things that Engineering students look for is the move from graphing calculators to solving problems in a way that doesn’t require an expensive tool like MatLab or Mathematica, although both are excellent tools. When engineers leave school, it sometimes comes as a rude shock that the company they go to work for can’t afford the MatLab or Mathematica licenses.

First, don’t get me wrong, MatLab and Mathematica are great tools and later I am going to cover the use of F# with these important tools (if I can get a copy of one of them to work with).

Over the past 30 years I have been an Electrical Engineer, and Electrical Engineers are often trapped between the physics of the universe on one side, mechanical engineers on the other, then computer science on the opposite side. No one seems to understand the Electrical Engineer, it doesn’t help the Einstein’s equivalent of an undergraduate degree was in Electrical Engineering, that likely made it worse as the 20th century wore on. Mechanicals and Civil engineers have similar complaints, Computer Science seems to have a desire to exist to create and solve problems unique to the domain of the computer. And frankly they have done a great job of creating new technologies and jobs that employ 100’s of millions of people, so GOOD JOB Computer Scientists! But the engineering and science types need a little love too, which with imperative programming such as C#, Java is not really able to supply.

Let’s take a look at a situation that sits between electrical engineering and mechanical engineering: Control Systems. If I am designing a control system, I am not comfortable with object oriented software. If I am doing a simulation of a control system over a long period of time, imperative programming isn’t something that does me much good. Object Oriented programming is great for social networks, games, office applications, networks, but not for the control system simulation.

What is needed to excite the engineering students about programming? The physics student? Over the next few posts I will lay down some thoughts, and they will lead to functional programming with a dash of object oriented programming.

Do you have any thoughts on how a syllabus would look for non-CS students to get into programming?

Technorati Tags: F#,FSharp,Functional Programmning

Checking out the Microsoft Speech Server

SoCal Sam — Mon, 12 Jan 2009 23:02:00 GMT

This blog has been moved to the following blog. Why? I decided that I want to reactivate my Software Engineering Blog and this is fitting. If you came here from DevSchool, I will make changes on that blog as well...

http://blogs.msdn.com/socal-sam/archive/2009/01/30/checking-out-the-microsoft-speech-server.aspx

F#, Imperative Languages and Identifiers

SoCal Sam — Tue, 30 Dec 2008 00:21:38 GMT

OMG! I got pulled off my usual job of doing a bunch of things and have been focused on getting students involved in the Imagine Cup Software Design Invitational in the United States. Then it was Christmas and I ate to many cookies, etc. Finally I ignored my one comment from a int19h, and when you get as few comments as I do, everyone is precious!

Int19h ask about my previous blog:

"This is one of the differences between functional programming (F#, OCAML) and imperative programming (C#, VB.NET, Java), the concept of identifiers is not really supported in the imperative languages, although there are constants.
Can you explain what you mean by "the concept of identifiers is not supported"? Try as I might, I cannot parse this in such a way as to produce some meaning."

Fair enough int19h, just what in the heck was I saying? Well, if I had wrote my next blog on the day I thought about it, instead of focusing like a laser on getting the students involved with Imagine Cup (hopefully my manager is reading that!). The concept of the identifier in F# could be explained with this quote from Chris Smith's blog entry, F# in 20 Minutes:

"...using the term ‘value’ to refer to identifiers rather than ‘variable’. The reason for this is that types in F# are immutable by default, meaning that once they are created they cannot be changed. This may seem like a severe limitation, but immutability actually prevents some classes of bugs. In addition, immutable data is inherently thread safe meaning you don’t need to worry about sync locks in order to make your code parallelizeable."

What is an "Identifier"? Identifiers give names to values in F# for reference later in a program. You would use the keyword 'let', in the following manner, no semi-colon:

let x = 15

When a value is assigned to an identifier, it never changes in a functional program. The style is to refer to this construct as identifiers and not variables, see the book "Foundations of F#", by Robert Pickering.

Functions and Values in F# are treated exactly the same, also, functions in F# supports passing less arguments than the function supports, which is referred to as partial or curried functions. For more information on this see this excellent Podwyski's blog entry.

Are you interested in loading up F# and Visual Studio but don't want to buy or load the full version of Visual Studio? This is a great way to learn about the Visual Studio Shell and to get started with F#, if you have VS Pro or VS team system, then you only need to load up F#, unless you want to add Visual Studio Shell to your development tools, go ahead and load it.

First download and install the Visual Studio Shell:

Microsoft Visual Studio 2008 Shell (integrated mode) Redistributable Package

Then download and install F# CTP:

Microsoft F#, September 2008 Community Technology Preview

Have fun, make sure to check out the various blogs out there, so much good stuff, so little time!

F# variables or a return to BASIC?

SoCal Sam — Sat, 06 Dec 2008 03:42:00 GMT

In the example I used in the past post utilized the "let" command and it didn't have any data type, what's up with that? Oh it gets worse, the identifier (not variable) are immutable. That is the memory location of the identifier cannot be modified. To create an mutable identifier you have to declare the identifier as mutable. This is one of the differences between functional programming (F#, OCAML) and imperative programming (C#, VB.NET, Java), the concept of identifiers is not really supported in the imperative languages, although there are constants. This is not to say that F# doesn't support imperative programming, F# is object oriented, but it's focus on the functional approach to programming.

Identifiers are interesting, and to continue the discussion about solving engineering problems, we definitely will need to deal with functions. Functions easy to work with in F#, and we will take a look at functions in the next episode of the blog, mainly because I need to work on my game blog at http://blogs.msdn.com/devschool, where you can learn how to build a game for a Christmas Present this year!

Using F# to solve a standard engineering problem

SoCal Sam — Thu, 04 Dec 2008 00:59:00 GMT

F# has many interesting features, such as the use of lists, maps, and so forth. There are many blogs and websites dedicated to discussing the computer science side of F#, and for good reason the language supports these types of efforts. However, what about the rest of the computational users, for instance engineering students who are studying physics and want to generalize their homework problems in case they can use them when they are interns or are working after the leave school. After all, the homework that you do does serve a purpose other than getting a grade in class.

Please note that any discussion about using F# in my blogs are simply to illustrate the use of F# and not to make a statement that it is better than any other language or system such as Mathematica or Matlab, in fact F# is designed to work with those products as a friendly kind of language.

To get started, let’s take a look at how one F# can be used a very basic Ohm’s Law problem.

Let's take a look at a simple problem of electrical resistance.

Using Ohm’s law, Voltage= Current divide by Resistance or V=IR. If we know the total resistance and voltage, then current equals voltage divided by total resistance.

Let's use a circuit made up of three resistors that equal 40 ohms, 50 ohms and 60 ohms that are connected to a voltage source of 3 volts. To determine the current then I would divide the total voltage by the total resistance.

The equation would look like: current = voltage/(Resistor1 + Resistor2 + Resistor3).

Let’s write a simple F# program and a C# program to do the calculation:

Both sets of code look pretty much the same, and if we want to use it to solve circuits, we would have to insert the new values every time. In the next blog entry, we will take a look at using Excel for our input system. It isn't pretty, nor is it practical, but it does give us a basis of a simple application that can be built on over a number of blogs. Like many academic

F# form of the calculation

(Formatting is correct)

C# form of the calculation

(Formatting is correct)

#light

open System

let v1=3.0

let r1=40.0

let r2=50.0

let r3=60.0

let i1=v1/(r1+r2+r3)

Console.WriteLine(i1)

Console.Read()

using System;

class SeriesResistance

{

static void Main(string[] args)

{

double v1 = 3;

double r1 = 40;

double r2 = 50;

double r3 = 60;

double i1;

i1 = v1 / (r1 + r2 + r3);

Console.WriteLine(i1);

Console.Read();

}

problems we are starting simple, but since we are talking about real components like resistors that you might buy from Radio Shack or Fry's, there could be variations in values, the battery could vary between 2.50 volts (Ni-Cads) and 3.0 volts (Alkaline), plus the battery will vary with use as well. How do we model this kind of variations. How can we improve the input of the resistors, etc.

If you want to learn more about F# and how to use it to do lists, etc. take a look at the other blogs such as Don Syme, Chris Smith and http://www.hubfs.com. This blog will be utilize for me to figure out how to use F# to solve engineering and scientific problems that non-computer science and computer science students both might be interested in.

Happy Birthday John Blackus, inventor of FORTRAN

SoCal Sam — Wed, 03 Dec 2008 08:24:00 GMT

Dec. 3 is the birthday of John Blackus, he was one of the principle inventors of FORTRAN, see the article found at: http://en.wikipedia.org/wiki/FORTRAN

In my opinion, John Blackus best quote describing a motivation to continue to create programming systems:

· “Much of my work has come from being lazy. I didn't like writing programs, and so, when I was working on the IBM 701 (an early computer), writing programs for computing missile trajectories, I started work on a programming system to make it easier to write programs."

John Blackus received the Turing Award for his work in creating FORTRAN in 1978 and used the award to describe his thoughts on what a formal functional language could look like. Click on the link to his paper/speech "Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs".

Also, historically, John Blackus, invented one of the first high level languages for IBM machines called "speedcoding" in 1953, and the short article is fun to read and gives a historical perspective on floating point calculations: http://www.softwarepreservation.org/projects/FORTRAN/paper/p4-backus.pdf.

Finally, if you think you could use more memory, read about the memory on the IBM 701 that John Blackus was working with at:

The languages that John Blackus created were powerful and with FORTRAN long lasting, FORTRAN continues to be used in legacy scientific applications today, and was used extensively for 40 years after it's invention.

My challenge to you: How would you create a new language that helps you solve problems important to your career?

One way to get started on creating new languages would be read the article on Domain Specific Languages.
You can create programming languages that solve the problems that affect your life.

John Blackus was a pioneer in creating languages that were used by scientists and engineers to design the systems used by the American space program to reach the moon and beyond.

This is the type of research that drives the current world economy, and you can do your own research in languages using the Domain Specific Languages. F# was used to create the solver foundation, and example of Domain Specific Languages, check it out at:F# Optimization Modeling Language Utilizing Microsoft Solver Foundation

Have fun, create your own language or try out F#, a functional language!