Heat-shock Proteins Families

Heat-shock proteins are named according to their molecular weight (kilodaltons):

Approximate molecular weight (kDa)	Eukaryotic proteins	Function
10 kDa	Hsp10	Co-factor of Hsp60. Chaperonins: protein complexes that assist the folding of these nascent, non-native polypeptides into their native, functional state.
20-30 kDa	The HspB group of Hsp. Ten members in mammals including Hsp27 or HspB1
40 kDa	Hsp40	Co-factor of Hsp70
60 kDa	Hsp60	Involved in protein folding after its post-translational import to the mitochondrion/chloroplast
70 kDa	The HspA group of Hsp including Hsp71, Hsp70, Hsp72, Grp78 (BiP), Hsx70 found only in primates	Protein folding and unfolding, provides thermotolerance to cell on exposure to heat stress. Also prevents protein folding during post-translational import into the mitochondria/chloroplast.
90 kDa	The HspC group of Hsp including Hsp90, Grp94	Maintenance of steroid receptors and transcription factors
100 kDa	Hsp104, Hsp110	Tolerance of extreme temperature

The Hsp70/Hsp40 Family (Chaperone)

The 70 kilodalton heat shock proteins (Hsp70s) are a family of highly-related protein isoforms ranging in size from 66 kDa to 78 kDa. Proteins with similar structure exist in virtually all living organisms. The Hsp70s are an important part of the cell's machinery for protein folding, and help to protect cells from stress. The various family members are distributed throughout different intracellular compartments but nevertheless share many structural and biochemical properties.

These include: the cytosolic/nuclear Hsp70 proteins Hsc70 (a.k.a. Hsp73) and Hsp70 (a.k.a. Hsp72), Grp78 or Bip present within the lumen of the endoplasmic reticulum, and Grp75 (also called mortalin) localized within mitochondria. Hsc70 is constitutively expressed and poorly stress-inducible, whereas Hsp70 is unabundant in normal physiological situations and strongly induced under oxidative stress. Hsc70 was placed in the heat shock protein family due to homology with other heat shock proteins.

All of the mammalian Hsp70 family members require one or more cochaperones for their reaction cycle (HSP40 or HSP100).

The Hsp60/Hsp10 Family (Chaperonins)

The HSP60 (GroEL - Prokaryotic) proteins in combination with its particular co-factor Hsp10 (GroES - Prokaryotic) bind newly synthesized polypeptides and facilitate their folding to the native state in an ATP-dependent cycle. The binding and sequestration of the substrate polypeptide occurs within the large central cavity of the chaperonin complex. It is thought that protection of the substrate protein within the central cavity of the chaperonin provides a sequestered protein folding environment, thereby reducing the probability of misfolding and aggregation of the target protein with other polypeptides. The chaperonins together with Hsp70 chaperones coordinate the efficient folding and assembly of many proteins throughout the cell.

Hsp60 families are highly immunogenic proteins. The related GroEL proteins from different pathogens elicit strong humoral and cellular immune responses.

In mammalian the Hsp60 is localized within mitochondria and with its cochaperone, Hsp10, participates in the folding and assembly of newly synthesized proteins as they are transported into the mitochondria from the cytosol.

Hsp90

Hsp90 is a molecular chaperone and is one of the most abundant proteins expressed in cells. Unlike some of the other well characterized heat shock proteins whose chaperone role involves their interaction with many cellular proteins, Hsp90 exhibits some selectivity for a distinct set of “client” proteins. Hsp90 interacts with a variety of protein kinases and transcription factors important for growth and development. Working with its very large number of cochaperones, Hsp90 appears to maintain its client proteins in a conformation that allows for their subsequent activation in response to appropriate growth signals. Not surprisingly, Hsp90 and its co-chaperones are at the forefront of research for those studying signal transduction events and cancer.

Sources

• http://en.wikipedia.org/wiki/Heat_shock
• http://en.wikipedia.org/wiki/Heat_shock_protein
• http://en.wikipedia.org/wiki/Chaperone_%28protein%29
• http://en.wikipedia.org/wiki/Chaperonin
• http://en.wikipedia.org/wiki/Heat_shock_factor
• http://www.cs.stedwards.edu/chem/Chemistry/CHEM43/CHEM43/HSP/STRUCTURE.HTML
• http://www.antigenics.com/products/tech/hsp/
• http://www.assaydesigns.com/corp/images/literature/flier-heat-shock.pdf

Heat Shock and Heat Shock Proteins

Heat Shock

In biochemistry, heat shock is the effect of subjecting a cell to a higher temperature than that of the ideal body temperature of the organism from which the cell line was derived. In fish that survive at 0°C, heat shock can be induced with temperatures as low as 5°C, whereas thermophilic bacteria that proliferate at 50°C will not express heat shock proteins until temperatures reach approximately 60°C. The process of heat shocking can be done in a CO2 incubator, O2 incubator, or a hot water bath.

Induction of heat shock is a method by which genes can be introduced into cells via a vector. This is done by mixing the vector with competent bacteria in a microcentrifuge tube. First, the tube is cooled to a low temperature for several minutes, usually with an ice bath. The tube is then quickly moved into warm water, preferably around 42°C. This sudden change in temperature causes the pores to open up to larger sizes, allowing DNA molecules to enter. After a brief interval, the tube is quickly cooled to a low temperature again. This closes up the pores, and traps the DNA inside. With this, the cells would have been transformed. However, as with almost all transformation techniques, this method is far from 100% efficient.

from Wikipedia (accessed on 10/28/2009)

Heat Shock Proteins

Heat shock proteins (HSPs) are present in cells under normal conditions (1), but are expressed at high levels when exposed to a sudden temperature jump or other stress (2).

(1) HSPs act like ‘chaperones,’ making sure that the cell’s proteins are in the right shape and in the right place at the right time. For example, HSPs help new or distorted proteins fold into shape, which is essential for their function. Heat shock proteins also shuttle proteins from one compartment to another inside the cell, and transport old proteins to ‘garbage disposals’ inside the cell. Heat shock proteins are also believed to play a role in the presentation of pieces of proteins (or peptides) on the cell surface to help the immune system recognize diseased cells. HSPs appear to serve a significant cardiovascular role.

Chaperones are proteins that assist the non-covalent folding/unfolding and the assembly/disassembly of other macromolecular structures, but do not occur in these structures when the latter are performing their normal biological functions. Chaperones do not necessarily convey steric information required for proteins to fold: thus statements of the form `chaperones fold proteins` can be misleading. One major function of chaperones is to prevent both newly synthesised polypeptide chains and assembled subunits from aggregating into nonfunctional structures. It is for this reason that many chaperones, but by no means all, are also heat shock proteins because the tendency to aggregate increases as proteins are denatured by stress. However, 'steric chaperones' directly assist in the folding of specific proteins by providing essential steric information.

Heat shock proteins trigger immune response through activities that occur both inside the cell (intracellular) and outside the cell (extracellular).

• Intracellular activities: Because of the normal functions of heat shock proteins inside the cell (such as helping proteins fold, preparing proteins for disposal, etc.), HSPs end up binding virtually every protein made within the cell. This means that at any given time, HSPs can be found inside the cell bound to a wide array of peptides that represent a ‘library’ of all the proteins inside the cell. This library contains normal peptides that are found in all cells as well as abnormal peptides that are only found in sick cells. Research suggests that inside the cell, heat shock proteins take the peptides and hand them over to another group of molecules. These other molecules take the abnormal peptides that are found only in sick cells and move them from inside the cell to outside on the cell’s surface. When the abnormal peptides are displayed in this way, they act as red flags, warning the immune system that the cell has become sick. These abnormal peptides are called antigens — a term that describes any substance capable of triggering an immune response.
• Extracellular activities: Heat shock proteins are normally found inside cells. When they are found outside the cell, it indicates that a cell has become so sick that it has died and spilled out all of its contents. This kind of messy, unplanned death is called necrosis, and only occurs when something is very wrong with the cell. Extracellular HSPs are one of the most powerful ways of sending a ‘danger signal’ to the immune system in order to generate a response that can help to get rid of an infection or disease.

(2) HSPs are a part of the cell's internal repair mechanism. They are also called stress-proteins. They respond to heat, cold and oxygen deprivation by activating several cascade pathways. In fact, HSPs stabilize proteins and are involved in the folding of denatured proteins. High temperatures and other stresses, such as altered pH and oxygen deprivation, make it more difficult for proteins to form their proper structures and cause some already structured proteins to unfold. Left uncorrected, mis-folded proteins form aggregates that may eventually kill the cell. HSPs are induced rapidly at high levels to deal with this problem. Increased expression of HSPs is mediated at multiple levels: mRNA synthesis, mRNA stability, and translation efficiency.

Heat shock factor 1 (HSF-1) is the major regulator of heat shock protein transcription in eukaryotes. In the absence of cellular stress, HSF-1 is inhibited by association with heat shock proteins and is therefore not active. Cellular stresses, such as increased temperature, can cause proteins in the cell to misfold. Heat shock proteins bind to the misfolded proteins and dissociate from HSF-1. This allows HSF1 to form trimers and translocate to the cell nucleus and activate transcription.

from Wikipedia (accessed on 10/28/2009), from Wikipedia (accessed on 10/28/2009), from Wikipedia (accessed on 10/28/2009), from Wikipedia (accessed on 10/28/2009)

Eclipse+Grails+GWT: Integrating 'live' GWT [1]

After creating a Grails project in Eclipse (and a plugin), I want now to make use of GWT (Google Web Toolkit). For doing so I am going first to install the useful Google plugin for Eclipse (download). As I am working with Eclipse Galileo, I am installing the software using: http://dl.google.com/eclipse/plugin/3.5

If you are new to GWT I would suggest you to start creating a simple GWT project (without any Grails involved). Follow this.

Adding the gwt libraries to the classpath of the Grails project
If you installed the Eclipse plugin for GWT this would be a fairly simple step. Right click on the project and Properties->Java Build Path->Libraries->Add Library and I will find in the list the Google Web Toolkit in the list (this is obviously because I previously succesfully installed the Eclipse plugin for GWT).

An alternative way (to the Google plugin) would have been to define in the Eclipse Preferences->Java->Build Path->Classpath Variables the variable GWT_HOME that will point to the gwt installation (i.e. /Users/paolociccarese/Library/gwt-mac-1.7.1). If you haven't installed GWT yet, you can download it here. Then we are going to add to the libraries of the 'FirstApp' projects the jars included in the GWT distribution (Right click on the project and Properties->Java Build Path->Libraries->Add variable you can select GWT_HOME and extend it with the jars: gwt-api-checker, gwt-dev-mac, gwt-servlet, gwt-user.

Another way would be using ivy for resolving the dependencies.

The Grails plugin for GWT
Then I will install the Grails plugin for GWT. Once again, after positioning in the root of the 'FirstApp' project I will type:
> grails install-plugin gwt

At this point I am almost ready to go...

Eclipse+Grails: Adding a 'live' plugin to the project

Once created the new project 'FirstApp' I want to be able to create a Grails plugin in the Eclipse IDE. To create a plugin is pretty straightforward, I use the command line, after positioning in the root of the current workspace, and I type:
> grails create-plugin FirstPlugin

The Grails plugin structure is almost identical to the Grails application structure. See my previous post about the Grails plugin. I am going to import in Eclipse the plugin with the classic 'Import as Existing Project'. As I did for the 'FirstApp' I can enable the Groovy capabilities right clicking on the project and selecting: Configure-> Convert to Groovy project. Also, exactly as I did for the Grails application, I select the ivy.xml file, I right-clik and select 'Add Ivy Library...'. This will link, through ivy, all the libraries necessary to the newly created Grails application to compile and run. Once performed this step I can safely remove all the libraries linked in the subdirectory GRAILS_HOME from the Properties->Java Build Path. You should also notice a new icon in the toolbar with tooltip 'Resolve All Dependencies'. You can use that icon to retrieve new dependencies that you specified in the ivy.xml file.

For testing purposes I can run the plugin as it was an application with:
> grails run-app

After checking that the plugin can run I want to use the Grails plugin 'FirstPlugin' in the Grails application 'FirstApp'. The 'classic' way would be to package the plugin by command line. After positioning in the root of the plugin:
> grails package-plugin
will create a file like grails-firstplugin-0.1.zip. After positioning in the root of the app, I can then the installation of the plugin:
>grails install-plugin ../FirstPlugin/grails-firstplugin-0.1.zip

Unfortunately, this approach is really annoying and time consuming when using the Eclipse framework. In fact, every time the plugin is changing I have to package it again and install it again.

Well, in Eclipse there is a better way to go. First of all we create the file conf/BuildConfig.groovy in the 'FirstApp' project. In this file we are going to type:
grails.plugin.location.firstPlugin = "../FirstPlugin"

This will basically tell Grails to refer to that plugin specifying the plugin folder. To test this, after creating the file, you can proceed creating a controller in the plugin. After positioning in the plugin root, I type:
>grails create-controller org.example.First

This will generate a new controller org.example.FirstController .To prove that the BuildConfig.goovy file is working you can run the application. After positioning in the root of the application:
>grails run-app

Checking the URL: http://localhost:8080/FirstApp/ you should see the controller (of the plugin) showing up. There is still a problem though if you create a second controller (or a change in the code of the plugin), this will not show up in the application unless you restart the server. This might become extremely annoying on the long run.

The solution to that is the creation of a soft link. We are going to create a link to the plugin project inside the code of the application. First I create the directory plugins in the FirstApp project:
>mkdir plugins

Then, in that directory, I am going to create the link to the FirstPlugin:
>ln -s ../../FirstPlugin

Right. Now, if you followed correctly (...and if I have not forgot any step), while the server is running, you should be able to create a new controller in the 'FirstPlugin' and see it in the list of the controllers in the running application: http://localhost:8080/FirstApp/

One more thing, remember to refresh the eclipse project every time you make use of a Grails command that creates/modify files.

Eclipse+Grails: Setting up a new project

Here is my current setup for creating a Grails project with Eclipse:

1. Installed Eclipse jee 3.5 Galileo SR1 (download)
   
2. Installed SVN plugin Subclipse (Update site: http://subclipse.tigris.org/update_1.6.x)
   
3. Installed Groovy plugin (Update site: http://dist.codehaus.org/groovy/distributions/greclipse/snapshot/e3.5/)
4. Installed Ivy plugin (http://www.apache.org/dist/ant/ivyde/updatesite)

I am then going to setup the launcher for the Grails commands through the "External Tools Configuration". I am specifying the 'location of Grails" (i.e. /Users/paolociccarese/Library/Grails-1.1.1/bin/grails), then ${project_loc} as 'Working directory' (that means the command will be related to the selected project in the Eclipse workspace. Finally I define as 'Arguments': ${string_prompt} . This will allow me to run the Grails commands like I would do from the command line. To be honest I also use the command line when I am managing grails projects, for some operations is more practical.

Finally I create the GRAILS_HOME variable in Eclipse->Preferences->Java->Build Path->Classpath Variables. This is used by Eclipse to compile the project. You may notice that GROOVY_HOME and IVY_HOME have already been created by the plugins.

Now I want to create a new Grails application that I will call 'FirstApp'. For doing this I will use the command line and, after positioning myself in the root of the current workspace, I type:
> grails create-app FirstApp

This will create the structure of my new application (in the newly created directory: FirstApp). I can now import this structure as 'Import as Existing Project' in my workspace. I can enable the Groovy capabilities right clicking on the project and selecting: Configure-> Convert to Groovy project.

Now if you right-click on the project and select: Properties->Java Build Path you will notice tha all the libraries are linked in a subdirectory of GRAILS_HOME. This is not my solution as I want to be dependent from the ivy.xml file. To do so, I select the ivy.xml file, I right-clik and select 'Add Ivy Library...'. This will link, through ivy, all the libraries necessary to the newly created Grails application to compile and run. Once performed this step I can safely remove all the libraries linked in the subdirectory GRAILS_HOME from the Properties->Java Build Path. You should also notice a new icon in the toolbar with tooltip 'Resolve All Dependencies'. You can use that icon to retrieve new dependencies that you specified in the ivy.xml file.

Now I can test if the application is actually running. I select a file in the project and I run the external application 'Grails' that I previously created. A window will pop up and we can fill out the text box with the command 'run-app'. The alternative would have been to use the shall and, after positioning in the root of the project, type:
> grails run-app

If everything went right we can now browse: http://localhost:8080/FirstApp/ getting back the Grails welcome screen.