What is Multistage Rocket and it's Advantages

A multistage (or multi-stage) rocket is a rocket that uses two or more stages, each of which contains its own engines and propellant. A stacked stage is mounted on top of another stage; a parallel stage is attached next to another stage. The result is effectively two or more rockets stacked on top of or attached next to each other. Taken together these are sometimes called a launch vehicle. Two stage rockets are quite common, but rockets with as many as five separate stages have been successfully launched.

By jettisoning stages when they run out of propellant, the mass of the remaining rocket is decreased. This staging allows the thrust of the remaining stages to more easily accelerate the rocket to its final speed and height.

In stacked staging schemes, the first stage is at the bottom and is usually the largest, the second stage is above it and is usually the next largest. Subsequent upper stages are above those. In parallel staging schemes solid or liquid rocket boosters are used to assist with lift-off. These are sometimes referred to as 'stage 0'. In the typical case, the first stage and booster engines fire to propel the entire rocket upwards. When the boosters run out of fuel, they are detached from the rest of the rocket (usually with some kind of small explosive charge) and fall away. The first stage then burns to completion and falls off. This leaves a smaller rocket, with the second stage on the bottom, which then fires. This process is repeated until the final stage's motor burns to completion.


Advantages:

The main reason for multi-stage rockets and boosters is that once the fuel is burnt, the space and structure which contained it and the motors themselves are useless and only add weight to the vehicle which slows down its future acceleration. By dropping the stages which are no longer useful, the rocket lightens itself. The thrust of the future stages is able to provide more acceleration than if the earlier stages were still attached, or than a single, large rocket would be capable of. When a stage drops off, the rest of the rocket is still travelling near to the speed that the whole assembly reached at burn-out time. This means that it needs less total fuel to reach a given velocity and/or altitude.

A further advantage is that each stage can use a different type of rocket motor, with each stage/motor tuned for the conditions in which it will operate. Thus the lower stage motors are designed for use at atmospheric pressure, while the upper stages can use motors suited to near vacuum conditions. Lower stages tend to require more structure than upper as they need to bear their own weight plus that of the stages above them, optimizing the structure of each stage decreases the weight of the total vehicle and provides further advantage.

What is Achondroplasia

Achondroplasia is a type of dwarfism caused by inheritance of a mutated gene, or direct mutation of a gene. Since the cartilage fails to form properly, the bones cannot grow as they normally would. This results in failure for the bones to reach normal adult size. Most with Achondroplasia reach a height of about four feet (1.21 m) at adulthood.

Achondroplasia is called an autosomal dominant condition, because people need inherit only one gene mutation in order to cause the condition. Thus one parent with Achondroplasia has a 50% chance of passing on the gene to each child. Inheriting two genes for Achondroplasia is fatal.

If both parents have Achondroplasia, they have a 25% chance of passing on two of the mutated genes to each child. Two inherited genes for achondroplasia are usually not survivable. Sadly, children who inherit two mutated genes die at birth or shortly thereafter.

Even though Achondroplasia is considered autosomal dominant, there are some people who are born with the condition to parents without outward signs of dwarfism. They clearly don’t have the gene, because carrying the gene would mean they would have the condition. Thus in rare cases, the gene may mutate on its own and create the condition. Studies have shown this to be linked to mutations of the sperm cells from the father. Such mutations become more common as men age.

Still Achondroplasia is not exactly common. It is present in all races in about 1 in 20,000 to 40,000 births. That is .005% - .0025% of the general population. It remains a difficult, but relatively rare condition.

Generally, Achondroplasia can be diagnosed in utero through genetics testing early in the pregnancy, since the gene responsible has been identified. Further, ultrasound in the second half of a pregnancy shows signs of achondroplasia. In particular, length of the femur does not accord with its width as the pregnancy progresses.

Diagnosis after birth is made through physical exam and x-ray, which shows developmental problems with many of the bones. The adult with achondroplasia can be noted by his or her short stature, bowing of the legs, relatively large head but small nose, curvature of the spine, and short fingers and toes. Though the condition often brings unwanted comments from insensitive people, it is not life threatening.

There are a few complications common to those with Achondroplasia. They may have slightly delayed development as children, and are quite prone to ear infections. Some children have an increased risk for developing hydrocephalus, or water on the brain. Aside from these complications, which are present in many without Achondroplasia, the condition usually results in the same life span as those without the gene.

Recently doctors have begun attempting surgery and/or medication to help those with Achondroplasia achieve greater height. These surgeries include bone-lengthening surgeries, which break the bone and then stimulate regrowth in order to attain taller stature. Further, some physicians are experimenting with the use of human growth hormone on those with Achondroplasia to attempt greater growing potential. These studies are still in their infancy.

Some with dwarfism protest these interventions and criticize doctors, especially, for bone lengthening surgeries. These surgeries typically are quite painful for children for long periods of time. People with this form of dwarfism may argue that since the condition is not life threatening, these surgeries are merely cosmetic and inflict unnecessary pain on a child. Conversely, some parents feel the physical pain of surgeries may save children from experiencing the emotional pain of criticism by peer groups.

What is Multimedia?

Multimedia systems support the physical and logical coexistence and interactive use of heterogeneous media classes such as print, audio and video in specific application environments. Hypermedia and virtual reality applications are based on multimedia systems. Hypermedia extends the media-oriented features of multimedia systems by the concept of hyperlinks, i.e. logical structures that provide means for organizing media objects in a flexible, logically coherent, network-oriented and non-sequential way. Virtual reality extends the interaction-oriented features of multimedia by the concept of cyberspace, i. e. modeling objects and their behavior in virtual environments, integrating position-tracked man-machine interaction devices and performing numerically intensive computations to guarantee real-time navigation.

By definition, the media class print includes static media types such as text, graphics, facsimile and natural image; the media class audio includes dynamic media types such as natural and synthetic sound, speech, and music; and finally, the media class video includes dynamic media types such as natural and synthetic image sequences.

Multimedia systems, hypermedia and virtual reality still need much research before they can become common tools for industry and society. These topics, all closely related to applied computer science, represent the main stream of research and development carried out at the MultiMedia Laboratory. This institution was created in 1986 to serve the digital media interests and needs at the University of Zurich, in particular those arising in the natural science communities and at the business faculty.

The general research and development objectives of the MultiMedia Laboratory are: 1) to understand and develop information processing and telecommunication issues that arise in multimedia systems; 2) to conceptualize and realize advanced hypermedia and virtual reality prototypes for man-machine interaction, business data and scientific visualization, document processing and real-world computing; and 3) to apply these prototypes in the field of business, science, education and entertainment.

The current research and development activities at the MultiMedia Laboratory comprise theoretical studies and application related prototyping efforts. Specific topics of interest include: multimedia systems integration; handling of large data volumes; new techniques for data compression; storage managment for static and dynamic media elements; realization of media object distribution over networks; multimedia application frameworks and man-machine interfaces; development of experimental applications; evaluation of legal aspects in multimedia production; and last but not least, the general implications of multimedia systems as an enabling technology.

In order to conduct research and development activities from a perspective of applied computer science, the MultiMedia Laboratory team operates an advanced multimedia system infrastructure.

What is .NET Remoting?

Abstract

.NET Remoting provides a powerful and high performance way of working with remote objects. Architecturally, .NET Remote objects are a perfect fit for accessing resources across the network without the overhead posed by SOAP based WebServices. .NET Remoting is easier to use than Java's RMI, but definately more difficult than creating a WebService.

In this article, we will create a remote object that will return an Object read in from the database. I've also included an alternate object that omits the database functionality in order to allow those that don't have a database available to still play with .NET remoting. Make sure you are using Visual Studio.NET Beta 2 when attempting this project.
Step 1: Creating The Shared Library

Click on File->New->Project. Choose to create a new "C# Library" and name it ResumeServerLibrary then click on OK. This will create the "shared vocabulary" that both our .NET Remote client and Server will use to communicate.

The full code is below, if you would like to skip the database access portions, replace the ResumeLoader object with:


public class ResumeLoader : System.MarshalByRefObject
{

public ResumeLoader()
{
System.Console.WriteLine("New Referance Added!");
}

public Resume GetResumeByUserID(decimal userID)
{
return new Resume(1);
}
}

The namespaces required for the object. Please remember, if you're getting errors that the System.Runtime.Remoting.Channels.Tcp namespace does not exist, make sure you added the referance to System.Runtime.Remoting.dll as described above.


using System;
using System.Runtime;
using System.Data.SqlClient;

The namespace we're using for this particular object is DotNetRemoteTest, the object below is a MarshalByRefObject which means that instead of passing ResumeLoader over the wire, we're creating a referance and all of the work including the database work happens completely on the server side.


namespace DotNetRemoteTest
{

public class ResumeLoader : System.MarshalByRefObject
{
private SqlConnection dbConnection;

public ResumeLoader()
{
this.dbConnection = new System.Data.SqlClient.SqlConnection();
this.dbConnection.ConnectionString =
"data source=GRIMSAADO2K;initial catalog=underground;integrated security=SSPI;pers" +
"ist security info=True;workstation id=GRIMSAADO2K;packet size=4096";
/*Your connection string will be different. Database connections are beyond the scope of this article
*If you do not know how to create a database connection, please use the alternate version of this object */
System.Console.WriteLine("New Referance Added!");
}

public Resume GetResumeByUserID(decimal userID)
{
Resume resume = new Resume();
try
{
dbConnection.Open();
SqlCommand cmd = new SqlCommand(
"SELECT ResumeID, UserID, Title, Body FROM Resume as theResume WHERE theResume.UserID="+ userID +""
, dbConnection
);
SqlDataReader aReader = cmd.ExecuteReader();
if(aReader.Read())
{
resume.ResumeID=aReader.GetDecimal(0);
resume.UserID=aReader.GetDecimal(1);
resume.Title=aReader.GetString(2);
resume.Body=aReader.GetString(3);
}
aReader.Close();
dbConnection.Close();
}
catch(Exception x) { resume.Title="Error:"+x; }
return resume;
}
}

The Resume object needs to be serializable in order to be a return type of a remotely referanced .NET Remote object. The reason for this is the object will have to be turned into raw data to be passed over the network, then re-assembled into an object again on the other end.

This object is extremely simple, and to add to the simplicity of this tutorial, the constructor even initializes the fields with some default content.


[Serializable]
public class Resume
{
private decimal resumeID, userID;
private String body, title;

public Resume(decimal resumeID)
{
this.ResumeID=resumeID;
this.UserID=1;
this.Body="This is the default body of the resume";
this.Title="This is the default Title";
}

public decimal ResumeID
{
get { return resumeID; }
set { this.resumeID=value; }
}
public decimal UserID
{
get { return userID; }
set { this.userID=value; }
}
public String Body
{
get { return body; }
set
{
this.body=value;
}
}
public String Title
{
get { return title; }
set
{ this.title=value; }
}

}//END OF RESUME OBJECT

}//END OF DotNetRemoteTest namespace

Compile this project and you should have a DLL avaiable now to be added to your other assemblies.
Step 2: Create The Server Object

There are actually several ways to create the server object, the most straightforward is described below. In Visual Studio.NET, Click on File->New Project. Choose a Command Line Application and name it ResumeSuperServer.

First things first, we need to add referances to the required DLLs that will make this program work. Go to Project->Add Referance, and add a referance to the DLL that we created in Step1 by clicking the "Browse" button.

In order to use the .NET remote functionality, you must add a referance to the DLL using Project->Add Referance. Under the .NET tab, choose System.Runtime.Remoting.DLL and click on OK. Side note, to the authors of the .NET books out there that will remain nameless--Details like this are extremely important to someone trying to compile a .NET Remoting "hello world" :).
Next you will need to add a referance to System.Runtime.Remoting.dll the same way we did in Step 1.

The object below is fairly simple and straight forward. Below I'll explain each of the 3 lines of code that really matter to .NET remoting.

The TcpServerChannel is one of the two types of channels supported by .NET remoting. This will set up the port number we want our object to respond to requests on, and the ChannelServices.RegisterChannel will bind that port number to the TCP/IP stack on the operating system.


TcpServerChannel channel = new TcpServerChannel(9932);
ChannelServices.RegisterChannel(channel);

The other type of channel that can be set up is HTTP and is done simply by using the HttpServerChannel object in the System.Runtime.Remoting.Channels.Http namespace. The differances between using an HTTP and a TCP channel can be summed up simply--If you are working with a local network connection it's best to use TCP because of it's enhanced performance over using HTTP. If you're working over the internet HTTP can sometimes be the only choice depending on firewall configurations. Keep in mind that if you do have control over the firewall, almost all firewalls can be configured to allow TCP traffic through on the port you've chosen to use for you object in addition to the DNAT you'll likely need to employ in most situations. If you don't know how to alter these rules, ask your system administrator.


RemotingConfiguration.RegisterWellKnownServiceType(typeof(ResumeLoader),
"ResumeLoader", WellKnownObjectMode.SingleCall);

This line sets a few prameters on your service and binds the object you want to the name you want to use on this remote object. The first parameter is the object you're binding, typeof(ResumeLoader). The second parameter is the String that is the name for the object on the TCP or HTTP channel. For example, remote clients would refer to the above object as "tcp://localhost:9932/ResumeLoader". The third parameter tells the container what should be done with the object when a request for the object comes in. WellKnownObjectMode.Single call makes a new instance of the object for each client while WellKnownObjectMode.Singleton uses one instance of the object for all callers.

The complete code for the object is below.


using System;
using System.Runtime;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
using System.Data.SqlClient;
using DotNetRemoteTest;

namespace ResumeServerServer
{
public class ResumeSuperServer
{
public static void Main(String[] args)
{
TcpServerChannel channel = new TcpServerChannel(9932);
ChannelServices.RegisterChannel(channel);
RemotingConfiguration.RegisterWellKnownServiceType(typeof(ResumeLoader),
"ResumeLoader", WellKnownObjectMode.SingleCall);
System.Console.WriteLine("Press Any Key");
System.Console.ReadLine();
}
}
}

Compile this program and note the location of the generated .EXE file.
Step 3: Create The Remote Client

The ResumeClinet object is our test user of our newly created ResumeSuperServer remote object. To start this project go to File->New->Project. Choose a Console Application as the application type and enter "ResumeClient" as the project's name. As in step 2, make sure you add a referance to our shared DLL created in step 1 and the System.Runtime.Remoting DLL.

The code below has two lines of particular interest to .NET remoting. The first line creates a TCP client channel. This channel is not bound to a port. The seond line actually gets a referance to our remote ResumeLoader object. The Activator.GetObject method returns a type of Object that we can then cast into our ResumeLoader. The parameters we pass in are extremely similar to what we passed to the RemotingConfiguration object on the server project. The first parameter is the Type of the object, the second is the URI of our remote object.


ChannelServices.RegisterChannel(new TcpClientChannel());
ResumeLoader loader = (ResumeLoader)Activator.GetObject(
typeof(ResumeLoader), "tcp://localhost:9932/ResumeLoader");

The complete code for our ResumeClient is below.


using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
using DotNetRemoteTest;

namespace ResumeClient
{

public class ResumeClient
{

public static void Main(string[] args)
{
ChannelServices.RegisterChannel(new TcpClientChannel());
ResumeLoader loader = (ResumeLoader)Activator.GetObject(
typeof(ResumeServer), "tcp://localhost:9932/ResumeLoader");

if(rs==null)
{ Console.WriteLine("Unable to get remote referance"); }
else
{
Resume resume = loader.GetResumeByUserID(1);
Console.WriteLine("ResumeID:"+ resume.ResumeID);
Console.WriteLine("UserID:"+ resume.UserID);
Console.WriteLine("Title:"+ resume.Title);
Console.WriteLine("Body:"+ resume.Body);
}
Console.ReadLine();//Keep the window from closing before we can read the result.
}//END OF MAIN METHOD
}//END OF ResumeClient Object
}//END OF ResumeClientNamespace

Compile this project and note the location of the executable.

Hydrogen Peroxide

Hydrogen Peroxide is simply water with an extra oxygen molecule (H2O2) and breaks down into oxygen and water. It's certainly kinder on the environment. H2O2 is produced by both animal and plant cells and is formed naturally in the environment by sunlight acting on water.

Many industrial bleaching operations, such as those used in the production of paper, are increasingly moving towards the use of hydrogen peroxide for a greener bleaching process. It's also the active ingredient in many "oxygen" bleaches and is used extensively for lightening hair.

Do be careful when purchasing and handling this substance as some commercially available "food grade" hydrogen peroxide is 35% pure, highly corrosive and can be toxic or fatal if ingested at that strength.

Hydrogen peroxide should be diluted down to 3% as a base for most applications. It's also readily available in 3% solution from your local pharmacy or drugstore; which is probably the preferable and safer way to buy it, especially if you can take your empty bottles back for exchange/refilling - that can help cut down the cost.

If you choose to dilute a 35% solution yourself, add the hydrogen peroxide to distilled water rather than the other way around and wear gloves, body and eye protection when doing so.