text:
Some developers resent user interface programming because they believe it's all about painting icons, rewording text, and endlessly tweaking dialog boxes until an entire company agrees that an application looks attractive. Certainly, making a program usable, elegant, and even impressive (or cool) is no trivial task. It can even make the difference between indifferent customers and an enthusiastic audience that's willing to promote your product tirelessly. This kind of excitement about a program's look and feel has driven obscure products like Kai's Power Tools and even Microsoft Windows to great success, and it can't be overlooked. However, developers who are involved in creating and maintaining sophisticated enterprise-level applications realize that there is another set of design considerations for user interface programming. These are considerations about application architecture.
Application architecture determines how a user interface "plugs in" to the rest of an application. Today's development software (like MFC, Visual Basic, and .NET) makes this interaction relatively straightforward and, as a result, developers usually spend little or no time thinking about it. User interface code is usually inserted wherever is most immediately convenient at the time the program is written. This almost always leads to interface code that's tightly bound to a particular problem, scenario, or data source, and heavily interwoven with the rest of the application logic. The interface code might look good on the outside, but it's almost impossible to enhance, reuse, or alter with anything more than trivial changes. To make the jump from this type of scattered user interface coding to a more modern style you have to stop thinking in terms of windows and controls, and start looking at user interface as an entire interrelated framework.
This chapter explains how the principles of object-oriented programming and three-tier architecture apply to user interface design. It identifies the overall concepts that you'll return to again and again throughout the book, including:
The emphasis in this chapter is on general concepts. You'll see some code, but you won't learn about the intricate details like the properties and methods that controls provide. All these details are explored as we delve deeper into controls and user interface coding in the chapters that follow.
Classes and Objects
Today, it's generally accepted that the best way to design applications is by using discrete, reusable components called objects.
A typical .NET program is little more than a large collection of class definitions. When you start the program, your code creates the objects it needs using these class definitions. Your code can also make use of the classes that are defined in other referenced assemblies and in the .NET class library (which is itself just a collection of useful assemblies).
The Roles of Classes
It's important to remember that although all classes are created in the same way in your code, they can serve different logical roles:
Understanding the different roles of classes is crucial to being able to master object-oriented development. When you create a class, you should decide how it fits into your grand development plan, and make sure that you aren't giving it more than one type of role. The more vague a class is, the more it resembles a traditional block of code from a non–object-oriented program.
Classes and Types
The discussion so far has reviewed object-oriented development using two words: classes and objects. Classes are the definitions, or object templates. Objects are "live" classes in action. The basic principle of object-oriented design is that you can put any class to work, and use it to create as many objects as you need.
In the .NET world, however, these terms are a little blurred. The .NET class library is really built out of types, and classes are just one kind of type. To get the most out of this book, you should already know the basics about .NET types and how they can be used. If you need to refresh your memory and get reacquainted with .NET's object family, use the following sections.
Structures are like classes, but are generally simpler. They tend to have only a few properties (and even fewer important methods). A more important distinction is that structures are value types, while classes are reference types. This means that structures act differently in comparison and assignment operations. If you assign one structure variable to another, .NET copies the contents of the entire structure, not just the reference. Similarly, when you compare structures, you are comparing their contents, not the reference.
structureA = structureB; // structureA has a copy of the contents of structureB. // There are two duplicate structures in memory. if (structureA == structureB) { // This is true as long as the structures have the same content. // Using full binary comparisons like this can slow down performance. }
Some of the structures in the class library include Int32, DateTime, and graphics ingredients like Point, Size, and Rectangle.
This is the most common type in the class library. All the Windows and Internet controls are full-fledged classes. The word "classes" is sometimes used interchangeably with "types" (or even "objects") because classes are the central ingredients of any object-oriented framework like .NET. Many traditional programming constructs (like collections and arrays) are classes in .NET.
Unlike structures, classes use reference type equality:
objectA = objectB; // objectA and objectB now both point to the same thing. // There is one object, and two ways to access it. if (objectA == objectB) { // This is true if both objectA and objectB point to the same thing. // This is false if they are separate, yet identical objects. }
Occasionally, a class can override this behavior. For example, the String class is a full-featured class in every way, but it overrides equality and assignment operations to work like a simple value type. This tends to be more useful (and intuitive). For example, if a string acted like a reference type it would be harder to validate a password. You would need a special method to iterate through all the characters in the user-supplied text, and compare each one separately. Arrays, on the other hand, behave like traditional objects. If you want to perform a sophisticated comparison or copy operation on an array, you need to iterate through every item in the array and copy or compare it manually.
Delegates define the signature of a method. For example, they might indicate that a function has a string return value, and accepts two integer parameters. Using a delegate, you can create a variable that points to a specific method and invoke the method through the delegate.
Here's a sample delegate definition:
// To define a delegate, identify the method's parameters and return type. public delegate string StringProcessFunction(string input);
You can then create a delegate variable based on this definition, and use it to hold a reference to a method:
StringProcessFunction stringProcessor; // This variable can hold a reference to any method with the right signature. // It can be a static method or an instance method. You can then invoke it later. // Here we assume that our code contains a function named CapitalizeString. stringProcessor = new StringProcessFunction(CaptitalizeString); // This invokes the CaptializeString function. string returnValue = stringProcessor("input text");
Besides being an interesting way to implement type-safe function pointers, delegates are also the foundation of .NET's event handling.
Enumerations are simple, static types that allow developers to choose from a list of constants. Behind the scenes, an enumeration is just an ordinary integer where every value has a special meaning as a constant. However, because you can refer to enumerations by name, you don't need to worry about forgetting a hard-coded number, or using an invalid value.
// You define enumerations in a block. public enum SqlQuery { SelectAllOrders, SelectAllCustomers }
Once you have defined an enumeration, you can create enumerations like any other variable. When you assign a value to an enumeration, you use one of the predefined named constants.
// You create an enumeration like an ordinary variable. SqlQuery dBQuery; // You assign and inspect enumerations using an object-like syntax. dbQuery = SqlQuery.SelectAllOrders;
Enumerations are particularly important in user interface programming, which often has specific constants and other information you need to use but shouldn't hard-code.
Interfaces are special contracts that define properties and methods that a class must implement. Interfaces have two main purposes in life. First, they allow polymorphism, which means many different objects that use the same interface can be treated the same way. For example, if you implement an interface called IFileAccess, a client program may not know the specific details about your class, but if it understands IFileAccess it knows enough to use a set of basic file access functionality.
// You can access a supported interface by casting. IFileAccess recognizedObject; recognizedObject = (IFileAccess)MysteryObject; // If IFileAccess supports a method, the object that implements it will too. recognizedObject.OpenFile();
Interfaces are also useful in versioning situations, because they allow you to enhance a component without breaking existing clients. You simply need to add a new interface.
More About Objects
If you haven't had much experience with this type of object-oriented or interface-based programming, I encourage you to start with a book about .NET fundamentals, like A Programmer's Introduction to C# or Programming VB.NET: A Guide for Experienced Programmers, both from Apress. Classes and other types are the basic tools of the trade, and you need to become comfortable with them before you can start to weave them into full-fledged object models and architectures.
User Interface Classes in NET
The first step when considering class design is to examine what rules are hardwired into the .NET framework. Your goal should be to understand how the assumptions and conventions of the .NET platform shape user interface programming. Once you understand the extent of these rules, you will have a better idea about where the rules begin and end and your object designs must take over.
Controls Are Classes
In the .NET framework, every control is a class. Windows controls are clustered in the System.Windows.Forms namespace. Web controls are divided into three core namespaces, including System.Web.UI, System.Web.UI.HtmlControls, and System.Web.UI.WebControls.
In your code, a control class acts the same as any other class. You can create it, set its properties, and use its methods. The difference is in the lineage. Every Windows control inherits from System.Windows.Forms.Control, and acquires some basic functionality that allows it to paint itself on a window. In fact, even the containing window inherits from the Control base class.
On its own, a control object doesn't do much. The magic happens when it interacts with the Windows Forms engine. The Windows Forms engine handles the Windows operating system messages that change focus or activate a window, and tells controls to paint themselves by calling methods and setting properties. The interesting thing is that although these tasks are performed automatically, they aren't really hidden from you. If you want, you can override methods and fiddle with the low-level details of the controls. You can even tell them to output entirely different content.
So it's clear how you create a control—you just create an instance of a control class, as you would do with any other object. Here's an example that defines a text box:
System.Windows.Forms.TextBox txtUserName = new System.Windows.Forms.TextBox();
You can then set various properties for your control:
txtUserName.Name = "txtUserName"; txtUserName.Location = New System.Drawing.Point(64, 88); txtUserName.Size = New System.Drawing.Size(200, 20); txtUserName.TabIndex = 0; txtUserName.Text = "Enter text here!";
These properties configure some important information, like the size and position of the text box. But none of this actually creates a visible control in a window. How does the Common Language Runtime know whether you are just creating a control to use internally (perhaps to pass to another method) or if you want it to be painted on a specific form and able to receive input from the user?
The answer is in class relations.
Controls Contain Other Controls
The System.Windows.Forms.Control class provides a property called Controls, which exposes a collection of child controls. For example, a Windows Form has a Controls property that contains the first level of contained controls that appear in the window. If you have other container controls on the form, like group boxes, they may have their own child controls.
In other words, controls are linked together by class relations using the Controls collection. Because every control is a special class that derives from System.Windows.Forms.Control, every control supports the ability to contain other controls. (In fact, in Chapter 10 you'll see an example of docking windows that works by placing a form control inside a panel control.)
Figure 2-1 shows a sample window, and Figure 2-2 diagrams the relationship of the controls it contains.
To associate a control with a window, you just need to add it to the form's Controls collection. Like most collection classes, the Controls collection provides some standard methods like Add() and Remove().
For example, the following line of code takes the text box control object and registers it with the form. The text box immediately appears in the window:
Or, if it you want the text box to be located inside a group box or panel:
// Add the panel to the form. frmMain.Controls.Add(pnlUserInfo); // Add the textbox to the panel. pnlUserInfo.Controls.Add(txtUserName);
The control's location property is automatically interpreted in terms of the parent control. For example, (0, 0) is the top left corner of the container, and (100, 100) is 100 pixels from both the top and left edges.
If you add a control to a form window that already exists, it appears immediately. If, however, the form hasn't been displayed yet, you need to use the form's Show() or ShowDialog() method. Forms are the only controls that know how to display themselves, and they automatically handle the responsibility of coordinating the display of all their contained controls.
A control can be removed from a window by using the Remove() method of the Controls collection. In this case, you need to supply a variable that references the control you want to remove.
// Remove the textbox control. frmMain.pnlUserInfo.Controls.Remove(txtUserName);
All controls, whether they are text boxes, buttons, labels, or something more sophisticated, are added to (and removed from) container controls in the same way. In the next section you see how you use this to your advantage by defining and displaying your custom controls.
Controls Derive from Other Controls
In Moving to VB .NET, Dan Appleman suggests that inheritance is an over-hyped feature with a few specific uses, but a host of potential problems and considerations. In his words, inheritance is the "coolest feature you'll never use," and many object-oriented gurus would be quick to agree. While inheritance can be useful when creating your business and data objects, it's generally not the best approach, and never the only one.
In the world of controls, however, inheritance just might be the single most useful feature you'll discover. Essentially, inheritance allows you to acquire a set of specific functionality for free. You don't need to worry about how to handle the messy infrastructure code for what you want to do. Instead, you simply inherit from a class in the .NET library, add a few business-specific features, and throw it into your program.
This approach can be used to create customized controls quickly and easily. Below is the definition for a custom text box. It has all the powerful features of a text box, manages its appearance automatically, provides sophisticated user editing capability, and takes care of basic details like painting itself and managing focus. In addition, the custom text box adds two new features. It has a property that returns the total number of letters in the text string (NumberOfLetters), and a method that quickly trims off extra dashes (TrimDashes). To provide this functionality, it uses some standard .NET tricks to iterate through a string, and it makes use of the Trim() method that's built into the string object.
public class CustomTextBox : System.Windows.Forms.TextBox { public int NumberOfLetters { get { int letters = 0; IEnumerator enumerator = Text.GetEnumerator(); while (enumerator.MoveNext()) { if (char.IsLetter((char)enumerator.Current)) { letters += 1; } } return letters; } } public void TrimDashes() { this.Text.Trim(char.Parse("-")); } }
You can use this class in exactly the same way that you would use a class from the .NET library:
CustomControlProject.CustomTextBox txtUserName; txtUserName = new CustomControlProject.CustomTextBox(); txtUserName.Name = "txtUserName"; txtUserName.Location = new System.Drawing.Point(64, 88); txtUserName.Size = new System.Drawing.Size(200, 20); txtUserName.TabIndex = 0; txtUserName.Text = "Enter text in the custom textbox here!"; frmMain.Controls.Add(txtUserName);
The interesting part of this example is not what's in the code, but what is left out. Clearly, there are a lot of Windows-specific details that you don't need to worry about when using inheritance to create a custom control. You also don't need to create separate ActiveX components (and countless versioning headaches). Custom controls in .NET are painless and powerful.
8 examine a variety of custom control programming techniques, and show you how to license, distribute, and manage them in the development environment. Custom control examples also reappear throughout the book. You'll use them to:
Creating custom controls is a key way of playing with .NET, and one of the most important themes of this book.
Inheritance and the Form Class
Inheritance isn't just used when you want to extend an existing class with additional features. It's also used to gain access to important parts of functionality in .NET. One of the best examples is the System.Windows.Form class.
In a Windows application, you could create an instance of a System.Windows.Form and manually go about adding controls and attaching events. However, if you are creating your project in Visual Studio .NET, it defaults to a more structured approach.
When you start designing a new window in the IDE, Visual Studio .NET automatically creates a customized class that inherits from the Form class. This class encapsulates all the logic for adding child controls, setting their properties, and responding to their events in one neat package. It also provides you with an easy way to create identical copies of a form, which is particularly useful in documentbased applications.
Below is a simplified example of a custom form class that contains a simple constructor method. When the form is instantiated in a program, it automatically creates and configures a text box, and then adds it to the form.
public class MainForm : System.Windows.Forms.Form { private System.Windows.Forms.TextBox txtUserName; public MainForm { txtUserName = new System.Windows.Forms.TextBox; txtUserName.Name = "txtUserName"; txtUserName.Location = new System.Drawing.Point(64, 88); txtUserName.Size = new System.Drawing.Size(200, 20); txtUserName.TabIndex = 0; txtUserName.Text = "Enter text here!"; this.Controls.Add(txtUserName); } }
The custom form class automatically gains all the features of a standard Windows.Forms.Form object, including the ability to display itself with the Show() and ShowDialog() methods.
// Create the form (at this point, its constructor code will run and add // the textbox control). MainForm frmCustomForm = new MainForm(); // Show the form. frmCustomForm.Show();
Notice how the only control MainForm contains (a text box) is referenced with a member variable, so that it can be easily accessed in your code. This means that once the form has been created, there are really two different ways to access the text box. The simplest way is to use the form-level member variable:
frmCustomForm.txtUserName.Text = "John";
It's up to you whether you want to make the member variable accessible to other classes in your program. By default, all control variables in C# are private, so they aren't available to other classes. In Visual Basic .NET projects, all controls are declared with the Friend keyword, and any other class can access them as long as it exists in the current project. This is similar to the way that previous versions of VB worked. Either way, the difference is minor. Generally, Visual Studio .NET tries to discourage you from breaking encapsulation and fiddling with the user interface of a form from another class. However, there is always one open back door. No matter what the language, you can always access controls directly through the form's Controls collection.
The Controls Collection
Generally, the member variables allow flat access to the controls on a form. All the controls on the form have corresponding member variables. On the other hand, only the first level of controls appears in the Controls collection. Controls that are inside container controls like group boxes, tab controls, or panels, will appear in the Controls collection of the control that contains them (as diagrammed in Figure 2-2).
Unfortunately, controls are only indexed by number in the Controls collection. That means the best way to find a control that you need is to iterate through the entire collection and examine each control one by one, until you find a match. You can look for a specific type of control, or a specifically-named control. For example, when a control is created in Visual Studio .NET, it is automatically given a Name property that matches the name used for the member variable.
txtUserName.Name = "txtUserName";
This is just a convenience—you are not forced to set the name property. However, it allows you to easily look up the control by iterating through the Control collection:
// Search for and remove a control with a specific name. foreach (Control ctrl in frmCustomForm.Controls) { if (ctrl.Name == "txtUserName") { frmCustomForm.Controls.Remove(ctrl); } }
Generating Code with Visual Studio NET
So far you've looked at the code to create control objects dynamically (a topic explored in much more detail in Chapter 11). When you use Visual Studio .NET to create code at design-time, the story is a little different—or is it?
When you create a Windows application in Visual Studio .NET, the IDE creates a customized form class. As you add, position, and configure controls in the design-time environment, Visual Studio .NET adds the corresponding code to a special region of the Form class, inside a method called InitializeComponent(). The form's constructor calls the InitializeComponent() method—meaning that the generated code is automatically executed every time you create an instance of your Form class (even before the form is displayed). A sample (commented and slightly shortened) Form class with an InitializeComponent() method is shown below. It configures the window shown in Figure 2-1.
public class TestForm : System.Windows.Forms.Form { // Form level control variables. // They provide the easiest way to access a control on the window. System.Windows.Forms.GroupBox groupBox1; System.Windows.Forms.Button button1; System.Windows.Forms.RadioButton radioButton1; System.Windows.Forms.RadioButton radioButton2; public TestForm { // Add and configure the controls. InitializeComponent(); } private void InitializeComponent() { // Create all the controls. groupBox1 = new System.Windows.Forms.GroupBox(); button1 = new System.Windows.Forms.Button(); radioButton1 = new System.Windows.Forms.RadioButton(); radioButton2 = new System.Windows.Forms.RadioButton(); // This is our way of telling the controls not to update their layout // because a batch of changes are being made at once. this.groupBox1.SuspendLayout(); this.SuspendLayout(); // (Set all the properties for all our controls here.) // (Configure the form properties here.) // Add the radio buttons to the GroupBox. this.groupBox1.Controls.Add(this.radioButton1); this.groupBox1.Controls.Add(this.radioButton2); // Add the button and group box controls to the form. this.Controls.Add(this.button1); this.Controls.Add(this.groupBox1); // Now it's back to life as usual. this.groupBox1.ResumeLayout(false); this.ResumeLayout(false); } }
The upshot is that a form and its controls are always created and configured through code, even when you design it with the IDE. The only difference between the theoretical code examples in this chapter and designed code is that the latter uses a dedicated InitializeComponent() method for better organization.
Interacting with a Control
One interesting and little-known fact about .NET controls is that they provide two different forms of interaction. The first, and less common one, is by creating custom classes and overriding methods.
For example, imagine you have a text box that's designed for numeric entry, and you want to examine every key press to make sure that it corresponds to a number, and not a letter. To perform this type of task, you can create a customized text box, and override the OnKeyPress() method to add this extra verification logic.
public class NumericTextBox : System.Windows.Forms.TextBox { protected override void OnKeyPress(KeyPressEventArgs e) { base.OnKeyPress(e); if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar)) { e.Handled = true; } } }
The OnKeyPress() method is invoked automatically by the Windows Forms engine when a key is pressed in a TextBox control. The overridden method in the example above checks to see if the entered character is a number. If it isn't, the Handled flag is set to true, which cancels all further processing, effectively making sure that the character will never end up in the text box.
This design pattern is useful if you use a number of controls with extremely similar behavior. If, on the other hand, you need to fine-tune behavior for distinct, even unique tasks, this approach is extremely poor. For example, consider a button control. You could react to a button click by creating a special class for every button on your application, and giving each button its own overridden OnClick() method. While your program would still be well encapsulated, it would quickly become completely disorganized, swamped by layers of button classes that have little to do with one another.
The View Mediator Pattern
The approach that .NET encourages circumvents this problem by using events. When you create a form in Visual Studio .NET, a custom class is derived for the form, but all the contained classes are used as is. The event handling logic is inserted as a series of special methods, which are added to the custom form class.
In other words, every form acts as a giant switchboard for all the controls it contains. This type of design pattern, which is so natural to .NET and most Windows development that you might not have even noticed it, is called the View-Mediator pattern. It dictates that one central class organizes each individual window.
Here's the same text box example you saw earlier, rewritten as form-level event handler. The event handler is hooked up in the constructor for the form (although Visual Studio .NET would perform the same task with a dedicated InitializeComponent() method).
public class MainForm : System.Windows.Forms.Form { System.Windows.Forms.TextBox txtUserName; public MainForm() { txtUserName = new System.Windows.Forms.TextBox(); txtUserName.Name = "txtUserName"; txtUserName.Location = New System.Drawing.Point(64, 88); txtUserName.Size = New System.Drawing.Size(200, 20); txtUserName.TabIndex = 1; txtUserName.Text = "Enter text here!"; this.Controls.Add(txtUserName); // Connect event handler. this.textBox1.KeyPress += new System.Windows.Forms.KeyPressEventHandler(this.textBox1_KeyPress); } private void textBox1_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e) { if (!char.IsControl(e.KeyChar) && !char.IsDigit(e.KeyChar)) { e.Handled = true; } } }
You'll notice that the actual logic for processing the key press is identical, but the way it's integrated into the application is completely different. The form is now responsible for the validation, not the control itself. This is an ideal approach if the form needs to handle the complex validation of multiple different controls. It's a less suitable approach if you need to perform the same type of validation for the same control in different windows, because you'll probably need to copy the code into multiple form-level event handlers.
You should also remember that the point of a switchboard is to route calls to a new destination. In other words, when you create the event handler for a button's Click event, this event handler usually has two purposes:
Depending on the button, only one of these tasks may be necessary. But the important concept you should realize is that an event handler is generally part of a user interface object-the form switchboard. It's meant to handle user interface tasks, and delegate more complicated operations to other objects.
Smart Controls
So far you have seen two distinct ways to use controls from the .NET class library:
The difference is shown in Figure 2-3.
Visual Studio .NET uses inheritance (the first method) when you create forms. When you configure controls, however, it inserts them as is, and adds the appropriate logic for modifying their properties (the second method). This is the default approach in .NET, but it is not the only approach.
When Visual Studio .NET adds controls and derives a custom form class, it is making a design decision for you. This decision helps clear out the clutter that would result from creating dozens of custom control classes. However, like all design decisions, it's not always right for all people and in all situations. For example, if you use numerous similar controls (like text boxes that refuse numeric input), you may find yourself duplicating the same code in event handlers all over your program. In this case, you might be better off to step beyond Visual Studio .NET's default behavior, and create customized controls with some additional intelligence.
When you are creating a new application and planning how to program its user interface, one of the most important tasks is deciding where to draw the line between smart controls (custom control classes) and smart switchboards (custom forms with event handling logic). A good decision can save a lot of repetitive work. 9 consider some examples that show how you can add a bit of sense to important controls like the TreeView and ListView. Hopefully, you'll realize that custom controls are not just for redistributing neat user interface elements, but also for building intelligence into parts of a large application, and helping to reduce repetition and enforce consistency across different modules.
Smart Forms
As explained earlier, every form class in your application is a custom class that derives from System.Windows.Forms. However, you can use multiple layers of form inheritance to centralize and reuse important form functionality. This topic is commonly referred to as visual inheritance (although it's no different than any other type of control class inheritance), and it's described in detail in Figure 2-4 diagrams this relationship.
So far, you've explored the basic object-oriented foundation of .NET user interface programming. The remainder of the chapter considers some higher-level architectural topics like encapsulation and three-tier design. These are the best practices you'll want to keep in mind when planning your user interface classes.
Encapsulation is the principle that suggests objects should have separate, carefully outlined responsibilities. Everything they need to fulfill these responsibilities should be wrapped up, hidden from view, and accomplished automatically, where possible. Encapsulation is often identified as a pillar of object-oriented programming, but it has played a part in program design since the invention of software. A properly encapsulated function, for example, performs a discrete well-identified task independently, and has a much better chance of being reused in another application (or even the same program).
The best way to start separating your user interface code is to think more consciously about encapsulation. The custom form class, with its "switchboard" design, is an excellent example of encapsulation at work. However, it also presents a danger. It potentially encourages you to mix in a great amount of additional material through the form's event handlers. A large part of good user interface programming is simply a matter of resisting this urge.
Of course, there are finer points to perfecting encapsulation. Custom controls, which handle some basic user interface operations on their own, are another good example. The following sections present guidelines that can help you keep encapsulation in mind. These techniques are not all immediately obvious. In this book, I'll return to the principle of encapsulation often, and show specific examples with common controls.
Use Enumerations and Resource Classes
User interface controls often require sets of constants, and trying to hard-code them is a tempting trap. Instead, you should create enumerations with meaningful names, and place them in dedicated resource classes. For example, you can define enumerations that help you manage and identify different levels of nodes in a TreeView control (see Chapter 6), distinguish different types of items in a ListView, or just pass information to other methods in your program. Extraneous details like SQL statements should also be strictly confined to distinct resource classes.
Use Collections
Objects are only as good as the way you can access them. On its own, a data object is a group of related information. By using a collection or other classes that contain collections, you can represent the underlying structure of an entire set of complex data, making it easier to share with other parts of your program.
Restrain from Sharing Control References
It's easy to pass control references to helper methods. For example, you can create utility classes that automatically fill common list controls. However, this type of design, where you rely on extraneous classes to perform user interface tasks, can make it extremely difficult to make even simple modifications to the user interface. As a rule of thumb, business code should never rely on the existence of a specific type of user interface control.
Define a Data Transfer Plan
The single greatest challenge when creating a reusable object framework is deciding how to retrieve data and insert it into the corresponding controls, without mingling the business and the presentation logic. To succeed, you may need to tolerate slightly long-winded code. You also need to create a clearly defined plan for transferring data that can be shared by all your forms and controls. In .NET, life just became a lot easier-the DataSet object makes a perfect, nearly universal solution for transferring information.
Use a Central Switchboard
The form acts as a switchboard for all the controls it contains. However, you shouldn't rely on forms for anything more. Instead, you should be able to remove a form, add a new one, or even combine forms without having to rewrite much logic. To accomplish this, forms should always hand off their work to another central switchboard, like an application class. For example, it may be easy to update a record in accordance with a user's selections by creating a new object in the form code and calling a single method. However, if you add another layer of indirection by forcing the form to call a more generic update method in a central application switchboard, your user interface gains a little more independence and gets closer to the ideal of three-tier design. Figure 2-5 shows how this process might work when updating a customer record. The update is triggered in response to a control event. The event handler calls a DoCustomerUpdate() form method, which then calls the required methods in the CustomerDB business object (and creates it if necessary).
Create Data Driven User Interfaces
As you prepare for a three-tier architecture, it's a good idea to start designing your user interface around the data it manages. This may sound like a slightly old-fashioned concept in today's object-oriented way, but it's actually a good habit to prevent yourself from subconsciously combining user interface and business processing logic.
Think of your user interface as having one "in" and one "out" connection. All the information that flows into your user interface needs to use a single consistent standard. All forms should be able to recognize and process this data. To achieve this, you might want to use data objects that rely on a common interface for providing data. Or, you might want to standardize on .NET's new DataSet object, which can convert information into XML and back seamlessly. The second part of Chapter 9 explores the ways you can tame data in a user interface.
Developing in Tiers
The basic principle of three-tier design is simple. An application is divided into three distinct subsystems. Every class belongs to only one of these three partitions, and performs just one kind of task. The three tiers are usually identified as:
An object in one tier can only interact with the adjacent tiers, as shown in Figure 2-6.
Almost everyone agrees that this sort of structure is the best way to organize an application, but it's not always easy to implement this design. Though the schematic looks simple, modern user interfaces are usually quite complicated, and sometimes make assumptions or have expectations about the way they will receive information. The result is that everyone recommends this model, but very few developers successfully follow it.
Problems with Three Tier Design
Before you can solve the problems of three-tier design, you have to understand what these problems are. The problems, although not insurmountable, are found in every tier.
The presentation tier
Though it doesn't explicitly state it, three-tier design really requires a fair degree of consistency among user interface controls. In the real world, this consistency doesn't exist. For example, making what is conceptually a minor change-like substituting a ListView control for a DataGrid-requires a totally different access model. DataGrids are filled exclusively by data binding. ListViews, on the other hand, act like a collection of items. To get information into other ListView columns, you have to add a collection of fields to each individual item. These quirks are easy enough to master (and you sort through them in Chapter 6), but they don't make it possible to create business objects that can quickly and efficiently fill common controls.
The business tier
In three-tier design, it's assumed that the user interface is isolated from the underlying data source. Information for a control is requested through a layer of business objects. This can be a problem if you create business objects that try to model real-world entities. For example, if you need to retrieve a list of customers and some summary information based on all customer orders, you would be crazy to try and work with individual Customer and Order objects. Consider the process:
Some three-tier designs get around this by creating a very thin business layer that might just consist of a pile of utility functions for retrieving rows as arrays. But is this really a good object-oriented design?
The data tier
Keeping the data tier separate from the business tier is another battle. To optimize performance, databases in enterprise applications usually rely on stored procedures, views, and other optimized ways to retrieve and update data. However, the user interface tier can't be built in a database-friendly way, because it is designed to be completely generic. It also can't rely on tricks that programmers' love, like dynamically generated SQL statements, because it is supposed to be completely isolated from the data tier. The result is a tradeoff, where you can favor any one of the following approaches:
Three Tier Design Consistency
There's nothing explicitly wrong with three-tier design, but it isn't a magic solution. For one thing, it's a rather vague recommendation that has more guidelines than requirements. Developers can interpret it any way they want.
For example, consider an application that reads customer information from a database and displays it in an attractive list control. At first glance, it seems like a straightforward task. But consider the number of different ways it could be modeled with objects:
Which approach is the best one? It's difficult to say. The third option is somewhat suspicious, because it seems that the CustomerData class is being given additional responsibilities beyond the scope it was designed for. Some of the other scenarios make assumptions about the appropriate way to exchange data. But the greatest problem with all of these examples is that there is no guarantee that the other classes in the application will follow this pattern.
Fixing Three Tier Design
By now you have probably realized that the most important decision you can make is to define how your user interface objects should interact. This is the simplest way to improve your designs without adopting a single specific solution.
To get a better idea about how you might apply three-tier design in the .NET world, consider the simple application below. It uses a TreeView that displays a list of product categories drawn from a database. When you expand a category node, you see all the relevant products. When a record is selected, the corresponding information appears on a list on the left (see Figure 2-7).
There are several important considerations:
Obviously, there are different ways this application can retrieve information from the database. It could use custom data objects, but that would require category and product objects that use multiple property procedures. The user interface code would then have to retrieve these properties specifically by name, and decide on an appropriate order. For some applications, this approach would work, but in this case it would choke a relatively simple browser with extra classes and code.
Using the DataSet
Instead, information in our example is sent in a neat package called the DataSet. The DataSet is found in the System.Data class, and is often referred to as a part of Microsoft's ADO.NET technology. Unlike the objects in earlier ADO, the DataSet is an ideal solution for information transfer in an application.
In other words, the DataSet removes some of the headaches of three-tier design. It allows a way to transfer information that's much more lightweight than dedicated classes, but not necessarily tied to a specific database. You can browse through its rows and fields as collections, which makes it easy to add information to list-like controls without needing to look for specific field names. Of course, when you want to start formatting column widths and setting column orders, your user interface may need to know a fair amount of information about the data. As long as you place this information in a central repository (generally a resource class with static members), your user interface will be extensible and easy to change.
Validation and Business Objects
Before continuing, allow me to debunk one myth about business objects. It's sometimes argued that business objects are an ideal way to store and transfer data because they can provide integrated error checking. In all honesty, the value of this error checking is limited. First, it's duplicating information in the database, which adds extra overhead for writing the code. More important, the error checking happens when the value is assigned, which is too late for it to be useful in the actual user interface. As you learned in the last chapter, the best thing you can do for users is to restrict their ability to make mistakes. That means you have to act on an error as soon as it happens, or better yet, forbid it entirely.
No matter what, your user interface has to be designed with some business rules built-in (for example, forbidding letters in a text box that represents an invoice amount). Your data source performs the final error checking. There's not much use in adding new layers of error checking between these two (except to verify that your client code is behaving correctly). Even the best three-tier design can't escape the need to import business rules into the interface.
Other Types of Application
The TreeView DataSet example above is a viable solution for many traditional database applications, which allow information to be reviewed, analyzed, and modified. Other types of applications may need other allowances.
The Last Word
Three-tier design is an abstraction. No successful application will implement it exactly. However, it's also a powerful guideline that helps you shape how classes interact in your application. It may seem strange to start talking about DataSets and business objects in a book on user interface design. (In fact, there are other excellent .NET books written entirely about data access.) But as you'll see, when you set specific rules about how the user interface tier can communicate with other parts of your program, you start to make the transition from a simple collection of objects to a true user interface framework.
The following chapters of this book focus on mastering the tools of .NET user interfaces. Considerations for design and user interface architecture crop up periodically, but they take a back seat to the amazing new programming model of .NET. This chapter was designed to give you the background in application architecture that you need to understand this "other layer." If you keep the considerations of this chapter in mind as you continue reading, you'll discover an entirely new and richer way to program user interfaces.
This chapter also introduced you to the broad picture of user interface in the .NET world, and the basic design assumptions that Visual Studio .NET makes automatically. These decisions can be altered, and the .NET framework itself allows you a considerable amount of freedom to create the exact framework that you want. In later chapters you'll learn how to exploit this freedom to create all types of custom controls.
Control Class Basics


text:
Help spread the word
You can help resolve the life crisis by helping spread the word. Please consider asking your family, friends and associates to download and read this book. If you click here you can get a ready-to-send email message with a link to this website included; just insert a destination email address and add a personal note if you like.
There are a few other ways you can help distribute this publication as well. If you own or administer a website dealing with conservation, please consider including a link on that site to www.SavingLifeBook.com. You may also want to mention the book on your personal website or blog, on FaceBook, through Twitter, or in web forums. Increasing public awareness is key to solving this problem, so please help in any way you can.

subset: commoncrawl


text:
- | The Virginia Gazette YORK – 29 acres between Williamsburg Ford and Great Wolf Lodge are in play for a 150,000-square-foot retail store.Planning documents indicate a single retail store along Rochambeau Drive and a 4,700-square-foot gas station with six pumps on 23 acres that are already zoned Economic Opportunity.
The documents filed this week indicate the store would be a wholesale retailer such as Sam's Club, BJs or Costco. The proximity to Wal-Mart suggests Sam's Club, although the traffic study used Costco as a model.
That would rub salt in the wound for James City County, which has resisted big-box stores but has to suffer their road traffic.
The business is projected to employ 200-300 employees at an average wage of $17 an hour and bring in around $125 million in sales worth millions to York County.
Property owner Alex Perkins said that because of a non-disclosure agreement he cannot reveal the retailer. He would retain ownership of six acres with the intention of selling them as out-parcels.
"We have not officially signed the contract but we have been given a nod by a major retailer," he said.
The sale of the land is contingent on the approval of the special use permit and whether the site budget shakes out in favor of the retailer.
"The president of the company has given us the nod that they are going to move forward with it as long as all the budget numbers makes sense," Perkins said.
Earlier this year the York supervisors denied an application to timber the property because no site plans had been filed.
Perkins said the application was not so much about timbering the land for profit as it was about getting the property ready for formal site preparations. With the new special use permit, the plans to timber the site are moot.
The property has a tributary stream along the southeastern property line, which feeds into the Waller Mill Reservoir. The area is within the county's watershed management and protection area and a 200-foot buffer would be required along the stream.
The City of Williamsburg, which owns the reservoir, has fought any development near the watershed for fear of runoff contamination.
City manager Jack Tuttle said that he is concerned about the possibility of a gas station going in near the watershed.
"We want to watch development in the watershed," Tuttle said. "We're certainly concerned about any hazardous materials that could leak into the reservoir."
The application is scheduled to go before the Planning Commission next month.
Filed under: General Area Information Hampton Roads Virginia, Real Estate information, Rezoning or Development | Tagged: retailers williamsburg va, williamsburg costco sams club, williamsburg virginia real estate agent | 3 Comments »


text:
Akıncı: 'Any attitude which ignores Turkish Cypriots is null and void'
President Mustafa Akıncı made a statement using his social media account and said 'Greek Cypriot Administration is stressing that making cooperation with Turkey is beneficial for all parties.
It is correct but missing a crucial point. The path which goes to cooperation with Turkey begins with cooperation with Turkish Cypriots.
Any attitude which ignores the Turkish Cypriot people is null and void'.


text:
UN report sets timescale for climate effort
Global greenhouse gas emissions must peak and start falling within one or two decades if extreme climate change is to be avoided, the IPCC warned in its third assessment report on mitigation, which assesses policy options and costs.
The International Panel on Climate Change (IPCC), the UN-led global authority on climate change, concluded that climate warming can be curbed through a mix of renewables, energy efficiency and reducing deforestation.
Global GHG emissions increased by 70% between 1970 and 2004 and continue to rise, climate experts warned in the latest report from the IPCC's Working Ground III, published after four days of talks at a conference in Bangkok.
"We can no longer make the excuse that we need to wait for more science, or the excuse that we need to wait for more technologies and policy knowledge," said Adil Najam, who contributed a chapter to the report.
"To me the big message is that we now have both, and we do not need to wait any longer," he said.
Apart from adapting our energy sources, lifestyles need to change, said IPCC chair Rajendra Pachauri said: "Human society as a whole has to look for changes in consumption patterns."
For more details see the full IPCC report.
Goska Romanowicz
© Faversham House Ltd 2023 edie news articles may be copied or forwarded for individual use only. No other reproduction or distribution is permitted without prior written consent.


text:
Every man or woman wishes to know the best methods to avoid or prevent Hair Loss. It is sad but true that one of the main causes of baldness in men is male pattern baldness or female pattern hair loss.
Men lose their hair from factors such as genetics, excessive aerobic exercise, excess stress, and hormone imbalance. Girls are affected by it just as much.
So, what are the most effective ways to prevent hair loss? Well, they certainly don't demand dint of gimmicks or expensive hair care products.
You can really use a few common-sense steps to help stave off thinning hair. Here are 5 ways to prevent hair loss.
5 Best Ways to Prevent Hair Loss
[lwptoc depth="2″]
1. Drink a lot of water
First, drink a lot of water. Water helps flush out toxins in your body that might otherwise promote hair fall. Furthermore, a lot of it also helps eliminate food left in your gut that contributes to hair fall.
So, wash fruits and veggies before you put them in your salads.
Plus, dehydration may lead to scalp infections and hair loss. Water also helps clear out your blood and toxins in the body which, in turn, nourishes your hair.
This may seem counterproductive, but it's not. Dehydration is a big problem in losing your hair.
2. Never wear a helmet, feather boa, or barrettes
Secondly, never wear a helmet, feather boa, or barrettes. These things are the most powerful ways to prevent hair loss since they pull on your scalp.
The pulling action only serves to make your hair more fragile. Pulling on your hair weakens it. Additionally, it contributes to breakage.
3. Avoid hot oil massages
Third, avoid hot oil massages. They tend to coat your scalp with oils which, over time, can make your follicles weak and prone to breakage. Instead, you can go for a cool, refreshing massage. riverpalm.comhttps://riverpalm.com
It breaks down adhesion, strengthens hair shafts, and prevents breakage.
4. Eat cherries daily
Fourth, eat cherries daily. Yes, even dark ones. These fruits contain special nutrients that are required to keep the pH levels of your scalp in perfect balance. A balanced pH level on your scalp is one of the best ways to prevent hair loss.
Dark cherries are rich in Vitamin C, folic acid, and manganese that help promote healthy follicles.
5. Avoid brushing wet hair.
Fifth, Avoid brushing wet hair. If you ask "why cant I brush my hair when it's wet", it's because Experts recommend to always brush hair dry before shampooing and conditioning because brushing tangles out of wet hair and scalp can lead to significant breakage.
Other tips
- Regularly wash your hair with a mild shampoo.
- Get some vitamins for hair loss. You can use Finasteride from Keeps if you suffer from hair loss for men.
- Enrich diet with protein.
- Scalp massage with essential oils.
- Avoid brushing wet hair.
- Garlic juice, onion juice, or ginger juice.
Video Tutorial about Natural Remedies to Stop Hair Fall
Why is My Hair Falling Out? Pattern Baldness
Hair loss in females or males can take many different forms. Some suffer from a female pattern baldness condition where they lose significant amounts of hair over a very short period of time.
Others do not suffer from this type of hair loss but only notice it when they take an important exam or get interviewed. Still, others lose hair due to certain medical conditions like diabetes, cancer, and hypothyroidism.
Each of these different types of hair loss has unique causes, but all of them share a common solution.
What is the Main Cause of Hairloss?
One of the common causes of pattern baldness is DHT or dihydrotestosterone. DHT is produced from testosterone, which is a male hormone, and the female-pattern version of this hormone is estrogen.
As we age, the levels of estrogen decrease which allows DHT to take its toll on our hair follicles and scalp.
In order to stop your hair from falling out, you need to find a natural supplement that contains the right blend of herbs, vitamins, minerals, and other plant-based ingredients.
Ingredients such as Saw Palmetto, Ginseng, Ginkgo Biloba, and Pumpkin seed are proven to block DHT in the body and put it in check. Plus they all have other benefits for the health of your overall health as well.
Aside from helping you stop female pattern baldness, there are many other benefits to be gained by taking this supplement on a daily basis. Some of these benefits include improved brain function and circulation.
Your skin will also benefit from the increased circulation that the Saw Palmetto provides. In addition to this Saw Palmetto is also known to prevent other conditions that can affect the female hormones including PMT, and even menopause.
So what should you do about the question of "why is my hair falling out female"?
Don't just take a random herb. Instead, choose a brand that features only the best ingredients and which has been designed by professionals in the hair loss industry.
This will ensure that you get the most effective treatment available for why is my hair falling out female.
Also, watch this video that will show you the best natural ways to stop hairfall.
Which hairstyles won't damage hair?
Some other hairstyles that won't damage hair are Ponytail Braided or Bun and bobs and weaves. These hairstyles tend to be good for those who have curly hair or have long hair. There is a lot of volume to the hair because of all the curls. They will look great and without damage.
If you are the type of person who usually has long hair, you should be aware that you should not have it straightened too much because this can damage the roots of your hair. People with short hair shouldn't be having it cut either too often.
This is because a lot of damage can be caused by the constant pulling and rubbing that happens when a person is trying to get their hair cut. Another type of hairstyle that won't damage hair is the mullet.
There have been a lot of people who have gotten a bad reputation from this hairstyle but what they didn't know is that the mullet does damage hair.
Other hairstyles that keep hair are Twisted Low Braid, Twisted Headband Hair Style, Loose Half Braid, Half-crown Braid and the Loose Half-up Tied Knot.
A lot of celebrities have made hairstyles that won't damage hair popular like Victoria Beckham. She has done different styles with her hair and each one looks great.
By paying attention to some key points, you can see that you've got a few of the best ways to prevent hair loss. These tips won't solve all your hair problems, but they will give you hope that you don't need to take any drastic measures to combat your thinning hair.
If you are looking for a natural way to regrow your hair and have that full head of hair you've always dreamed of, then you should know that the answer to your question, "Why is my hair falling out?", can be found in nature.
With herbs and other essential nutrients, you can restore that hair you've lost and stop balding before it takes place. Herbal hair remedies or taking supplements can really encourage hair growth.
But if you're suffering from a complete absence of hair, please consult with a doctor to get your hair to grow back.
Also Read:
Top 100 Popular Men's Haircuts to Look HOT| Men Hairstyles
Dandruff – Causes, Types, Best Treatments
99+ BEST Haircuts For Men To Look HOT
The 50+ Best Men Hairstyles & Haircuts to look HOT
The 40 Most Irresistible Black Girl Hairstyles to try


text:
Can you define success?
Success is not only about mastering groundbreaking achievements.
Success is all about mastering the mundane and boring things too!
A calm sea does not a great sailor make!
We are put to the test when there are windy bumps and crashing waves.
Our mind always wants something new and exciting. That's why we don't get excited over the mundane wins and everyday successes.
People create their own beliefs and opinions about themselves when they are young, thinking that they won't change.
It's not true.
We can always work on ourselves. Especially when we're younger.
When you start working on yourself, you will notice the opportunity everywhere!
Every challenge becomes an opportunity.
Within the problem you will find the seed on how to build the solution.
Success is the fruit of that inner work!
What actually IS success?
That remains the million dollar question…
What do you consider a success?


text:
GOD'S WORD® Translation
1The LORD spoke this message to the prophet Jeremiah about the nations.
2This is the message about Egypt, about the army of Pharaoh Neco, king of Egypt. King Nebuchadnezzar of Babylon defeated his army at Carchemish along the Euphrates River during the fourth year that Jehoiakim, son of Josiah, was king of Judah.
3"Get your large and small shields ready; advance into battle.
4Harness your horses. Mount up, you horsemen. Take your positions, and put on your helmets. Polish your spears. Put on your armor.
5"What do I see in them? They are terrified. They are retreating. Their warriors are defeated. They flee without looking back. Terror is all around them," declares the LORD.
6"The infantry can't flee. The warriors can't escape. They stumble and fall in the north by the Euphrates River.
7Who is this, rising like the Nile River, like streams that flow swiftly?
8Egypt is like the rising Nile River, like a river quickly overflowing its banks. Egypt says, 'I will rise; I will cover the earth. I will destroy cities and the people in them.'
9Go into battle, you horsemen. Drive wildly, you chariot drivers. March into battle, you warriors, you warriors from Sudan and Put who carry shields, you warriors from Lydia who use bows and arrows.
10That day belongs to the Almighty LORD of Armies. It is a day of vengeance when he will take revenge on his enemies. His sword will devour until it has had enough, and it will drink their blood until it's full. The Almighty LORD of Armies will offer them as sacrifices in the north by the Euphrates River.
11Go to Gilead, and get medicine, dear people of Egypt. You have used many medicines without results; you can't be cured.
12The nations have heard of your shame; your cry fills the earth. One warrior will stumble over another, and both will fall together."
13The LORD spoke this message to the prophet Jeremiah about the coming of King Nebuchadnezzar of Babylon, who will defeat Egypt.
14"Tell this in Egypt; announce this in Migdol. Make it known in Memphis and in Tahpanhes. Say, 'Take your positions, and get ready. Swords will kill those around you.'
15Why should your soldiers be cut down? They can't stand because the LORD will push them down.
16They have repeatedly stumbled, and now they have fallen. They say to each other, 'Get up! Let's go back to our people, to the land where we were born, and escape our enemy's sword.'
17There they will cry, 'Pharaoh, king of Egypt, is a big windbag. He has missed his chance.'
18"As I live," declares the king, whose name is the LORD of Armies, "someone who is like Mount Tabor among the mountains will come. Someone who is like Mount Carmel by the sea will come.
19Pack your bags, inhabitants of Egypt, because you will be taken away as captives. Memphis will become a dreary wasteland, a pile of rubble where no one lives.
20"Egypt is like a beautiful cow, but a horsefly from the north will attack it.
21Egypt's hired soldiers are like fattened calves. They will turn and run away together. They won't stand their ground. The day of destruction is coming. At that time they will be punished.
22Egypt will hiss like a snake as it slithers away. Its enemies will come with full force. They will attack it with axes like those who chop wood.
23They will cut down the forest," declares the LORD, "since Egypt can't be found. They are more numerous than locusts; they can't be counted.
24The people of Egypt will be put to shame. They will be handed over to the people from the north."
25The LORD of Armies, the God of Israel, says, "I'm going to punish Amon, who is the god of Thebes. I will also punish Pharaoh, Egypt, its gods, its kings, and whoever trusts Pharaoh. 26I'll hand them over to those who want to kill them, to King Nebuchadnezzar of Babylon and his officers. Afterward, they will live in peace as they did long ago," declares the LORD.
27"Don't be afraid, my servant Jacob. Don't be terrified, Israel. I'm going to rescue you and your descendants from a faraway land, from the land where you are captives. Then Jacob's descendants will again have undisturbed peace, and no one will make them afraid.
28Don't be afraid, my servant Jacob," declares the LORD. "I am with you. I will completely destroy all the nations where I scattered you, but I will not completely destroy you. I will correct you with justice. I won't let you go entirely unpunished."
GOD'S WORD® is a copyrighted work of God's Word to the Nations. Quotations are used by permission. Copyright 1995 by God's Word to the Nations. All rights reserved.
Bible Hub


text:
Recent Posts
- Incorporating Changing Reality into College Strategic Plans: Part 5: Extending Boundaries
- Incorporating Changing Reality into College Strategic Plans: Part 4: Incorporated Research
- Incorporating Changing Reality into College Strategic Plans: Part 3: How Do We Evaluate "Broader Impacts" in Research?
- Incorporating Changing Reality into College Strategic Plans: Part 2: Matching Students' Expectations
- Incorporating Changing Reality into College Strategic Plans: Part 1
- May 2023
- April 2023
- March 2023
- February 2023
- January 2023
- December 2022
- November 2022
- October 2022
- September 2022
- August 2022
- July 2022
- June 2022
- May 2022
- April 2022
- March 2022
- February 2022
- January 2022
- December 2021
- November 2021
- October 2021
- September 2021
- August 2021
- July 2021
- June 2021
- May 2021
- April 2021
- March 2021
- February 2021
- January 2021
- December 2020
- November 2020
- October 2020
- September 2020
- August 2020
- July 2020
- June 2020
- May 2020
- April 2020
- March 2020
- February 2020
- January 2020
- December 2019
- November 2019
- October 2019
- September 2019
- August 2019
- July 2019
- June 2019
- May 2019
- April 2019
- March 2019
- February 2019
- January 2019
- December 2018
- November 2018
- October 2018
- September 2018
- August 2018
- July 2018
- June 2018
- May 2018
- April 2018
- March 2018
- February 2018
- January 2018
- December 2017
- November 2017
- October 2017
- September 2017
- August 2017
- July 2017
- June 2017
- May 2017
- April 2017
- March 2017
- February 2017
- January 2017
- December 2016
- November 2016
- October 2016
- September 2016
- August 2016
- July 2016
- June 2016
- May 2016
- April 2016
- March 2016
- February 2016
- January 2016
- December 2015
- November 2015
- October 2015
- September 2015
- August 2015
- July 2015
- June 2015
- May 2015
- April 2015
- March 2015
- February 2015
- January 2015
- December 2014
- November 2014
- October 2014
- September 2014
- August 2014
- July 2014
- June 2014
- May 2014
- April 2014
- March 2014
- February 2014
- January 2014
- December 2013
- November 2013
- October 2013
- September 2013
- August 2013
- July 2013
- June 2013
- May 2013
- April 2013
- March 2013
- February 2013
- January 2013
- December 2012
- November 2012
- October 2012
- September 2012
- August 2012
- July 2012
- June 2012
- May 2012
- April 2012
- administration
- Anthropocene
- Anthropogenic
- assessment
- Biden
- Climate Change
- Conference
- coronavirus
- covid
- Economics
- Education
- Election
- Electric Cars
- Electricity
- Energy
- Extreme Weather
- Guest Blog
- Holocaust
- immigration
- law
- politics
- Population
- refugee
- Russia/Ukraine
- Sustainability
- Trump
- Water
About Micha
CCF around the Web
My Favorite Climate Change Sites
Social Media
Tag Archives: transportation
Back from Europe
As I have mentioned in previous blogs, after three years of COVID-19 hibernation, my wife and I just came home from visiting friends and family in England, Poland, and France. I will spend a few days teaching the first week … Continue reading
Posted in Climate Change, Energy Tagged air conditioning, Britain, C02, Coal, cooling, covid, Drought, dutch, Emissions, Energy, energy supply, Environment, Extreme Weather, France, Gas, Germany, inflation reduction act, Italy, Netherlands, Nuclear Energy, prices, Regulations, Russia, Spain, Switzerland, transportation, Ukraine, War, Water, Water Scarcity 5 Comments
Campus as a Lab: Part 1
Source: Rutgers Living Laboratories Campus as a lab (CAL) is becoming a teaching and organizational tool across campuses. I am including a schematic diagram of the dynamics of the concept, taken from the Rutgers University site, above. If you Google … Continue reading
Posted in Education, Energy, Sustainability Tagged academic, Adaptation, Brooklyn College, CAL, campus, carbon dioxide, Clean Energy, Climate Change, CO2, CO2 emissions, Columbia, CUNY, curriculum, decarbonization, diversity, Duke, Education, Emissions, Energy, energy transition, Environment, environmental studies, Florida State, Future, Interdisciplinary, lab, Mitigation, Net-Zero, offset, plastic, Princeton, Research, Sustainability, transportation, Water Leave a comment
Infrastructure Timing
They did it! Today, after a long slog of debate, the US Senate has finally passed a bipartisan version of the infrastructure bill that came out of the American Jobs Plan the Biden administration proposed in April. For more information … Continue reading
Posted in Climate Change, Economics, Energy Tagged Adaptation, Biden, bill, bipartisan, China, Clean Energy, Climate Change, commercial, competiiton, consumption, Cost, electric car, Electricity, Energy, energy cost, energy services, energy transition, fossil fuel, house, industrial, Infrastructure, input, manufacturing, mining, Mitigation, output, Physics, r&d, refining, residential, senate, Solar, Sputnik, transportation, US, utilities, Wind Leave a comment
The American Jobs Plan
I started to write this blog a day after President Biden presented his infrastructure plan in Pittsburgh, Pennsylvania. The location's symbolism was obvious; this was the same city where President Trump announced his withdrawal from the Paris Agreement: I was … Continue reading
Posted in Climate Change, Sustainability, US Tagged Adaptation, American jobs plan, Biden, budget, building, Climate Change, Cost, Electricity, Energy, Future, Infrastructure, jobs, law, manufacturing, Mitigation, Paris, Paris Agreement, Pittsburgh, Research, transportation, Trump, utilities 1 Comment
Income Inequality: Climate Apartheid
About three months ago (May 14, 2019) I featured a student-written guest blog on income inequality. That blog centered on transportation. It wasn't the first time that we have addressed the issue on Climate Change Fork. Previous blogs that focused … Continue reading
Posted in Climate Change, Economics, Sustainability Tagged Australia, Candidates, carbon dioxide, carbon emissions, carbon intensity, census, climate, climate apartheid, Climate Change, climate refugee, CO2, CO2 emissions, Economics, Emissions, equality, Future, Gas, gini coefficient, govering, Government, green job, green new deal, housing, Human Rights, Income, income distribution, Income Inequality, Inequality, money, OECD, Oil, pension, politics, Pollution, shelter, society, strategy, transportation, UN, vote 16 Comments
Electricity Use: Lighting – Incandescent vs. LED
In this blog, I would like to go through some details about judicious selection of the lighting devices that we use (e.g. incandescent, compact fluorescent, halogen or LED) and when or how much we choose to use our electricity. It … Continue reading
Posted in Climate Change, Electricity, Energy, Sustainability, US Tagged a/c, air conditioning, appliances, carbon emissions, cfl, commercial, compact fluorescent, economic, efficient, electrical power, Electricity, electricity access, electronics, Energy, Energy Consumption, energy efficient, energy star, energy transition, Environment, environmental, EPA, fluorescent, GDP, global energy transition, halogen, heat, home, incandescent, industrial, LED, light, light bulb, lighting, lumens, rebate, residential, sector, transportation, US, use, Voltage, wasted energy, Water, wattage, watts 4 Comments
Graduation: Congrats to My Students!
Classes ended this week. By the time that I post this blog, my students' final exams will also be history. The last four guest blogs were written by students in my Physics and Society course—a research-based course that I offer … Continue reading
Posted in Anthropocene, Anthropogenic, Climate Change, Education, Sustainability Tagged Adaptation, alternative energy, Anthropocene, Anthropogenic, asphalt, Bilingual, Brooklyn College, bus, butane, car, Carbon, carbon equivalent, Carbon Footprint, chemistry, Climate Change, Climate Change Denial, Climate Change Deniers, climate science, Climate Skeptics, CO2, CO2 emissions, Coal, coefficient, diesel, EIA, Electricity, emission factors, Emissions, Energy, energy transition, energy use, Environment, EPA, estimate, fuel, fuel oil, Future, Gas, Gasoline, Geothermal, Global Warming, greenhouse gas, heat, home energy, kerosene, language, literacy, lubricant, Mitigation, naptha, Natural Gas, Oil, petrochemical, petroleum, propane, Public Transportation, recycle, Science, Solar, Sustainability, transportation, US, waste Leave a comment
Guest Blog: How Income Inequality Correlates with CO2 Emissions and What We Can Do About It
Hello readers! This week's guest blog is from Benjamin K, Quinn Downes, and Michael Guerin. Combined, we carry degrees in the fields of physics, chemistry, and biology. Through this blog post, we hope to spread information on the correlation between … Continue reading
Posted in Anthropocene, Climate Change, Education, Guest Blog, Sustainability Tagged Anthropocene, Anthropogenic, Carbon, carbon emissions, cattle, Climate Change, CO2, CO2 emissions, correlation, developed, developing, Economics, Economy, Electricity, electricity generation, Emissions, Environment, environmental degradation, equality, GDP, gini coefficient, Global Warming, greenhouse gas, Guest Blog, Hypothesis, Income, income distribution, Income Inequality, industrial economics, Inequality, Kuznets, lognormal, Lorenz, Policy, Power, power plant, ratio, rural, Science, transportation, Turkey, urban, US 9 Comments
Guest Blog: How is Carbon Affecting Energy Intensity in the US?
Hello to everybody, we are the guest bloggers Amged Haimed, Junfeng Lu, and Haosheng Chen. We are all undergraduate students majoring in physics. Under the guidance of Micha Tomkiewicz, PhD, we have been able to use our backgrounds and experiences … Continue reading
Posted in Anthropogenic, Climate Change, Guest Blog, Sustainability, US Tagged alternative energy, California, Carbon, carbon dioxide, carbon intensity, CO2, CO2 emissions, Coal, commercial, Economics, Economy, Emissions, Energy, Energy Consumption, energy efficiency, energy intensity, Energy Sources, fossil energy, fossil fuel, Gas, GDP, graph, greenhouse effect, Guest Blog, housing, Hydroelectric, industrial, industrial production, industry, Natural Gas, New York, Nuclear, Physics, Pollution, Population, PPP, Renewable, residential, Solar, State, students, Texas, trade, transportation, US, Wind, wood 7 Comments
Electric Cars: What's Driving the Transition?
In the last two blogs I tried to show that without a parallel effort to decarbonize the power sources of electricity generators, our efforts to promote electric car fleets mean little in the scheme of progress against climate change. So—why … Continue reading
Posted in Anthropocene, Anthropogenic, Climate Change, Electric Cars, Sustainability Tagged America, Anthropocene, Anthropogenic, Belgium, Britain, California, car, Carbon, carbon neutral, carmaker, China, Clean Energy, clean power, Climate Change Denial, Climate Change Deniers, Climate Skeptics, CO2, CO2 emissions, Connecticut, Copenhagen, Costa Rica, decarbonize, Denmark, Electric Cars, electrical power, Electricity, Emissions, energy transition, Environment, fossil fuel, France, Future, Geothermal, Germany, global energy transition, Government, hydro, India, Ireland, Israel, Italy, Kenya, Maryland, Massachusetts, Morocco, New York, Nicaragua, Norway, Oregon, Paris, power plant, Quebec, regulation, Rhode Island, Rome, Science, Scotland, Solar, solar power, subsidize, subsidy, Sustainability, Sustainable, Sweden, Taiwan, Transition, transportation, UK, Uruguay, US, USA, vehicle, Wind, wind power 5 Comments


text:
Mineral makeup has increased in popularity in recent years, but do be aware that not all mineral makeup is created in the same way. Some contain fillers that you probably do not want to rub into your skin. Here's a rundown of the pros and cons of mineral makeup. The bottom line: read labels and know your makeup's ingredients.
April 23, 2012 By
The Scoop on Mineral Makeup
January 12, 2012 By
Corrective Makeup Tips & Techniques
It's easy to use corrective makeup techniques to highlight our best features — and play down features we aren't quite as fond of. You may already have most of the supplies required to start practicing corrective makeup skills, and can build your inventory over time, as you learn which products and shades work best.


text:
Share this with your remote team
The five rules of remote communication
Now that the corporate world has been dragged kicking and screaming into the world of remote work, we've all realized a few things. First, wearing pajamas to meetings is a lot less thrilling after a full week without changing out of them. Second, working on a remote team is really, really hard.
I'm not sure whether it's necessarily harder than an in-person team, but it's hard in different ways. Since we're all pretty new to this, that difficulty can take its toll. That leads to trouble: lack of productivity, disconnection, or just a serious drop in morale.
What's the deal? What makes remote work so much tougher on teams?
We don't have all the answers, but we have a humble thesis: it's because of the sudden & total reliance on written communication.
The rules of remote communication
Most of us office-workers are pretty good at verbal communication. We know how to bond with our coworkers, and how to conduct ourselves in a meeting. If we're a manager, we know how to lead those meetings in a way that gets everyone to nod their heads in understanding (or at least, pretend to).
Replacing all those meetings and off-the-cuff conversations with Slack messages and emails makes things harder. How do we ensure everyone has read and understood what we're saying? How do we brainstorm and collaborate?
Zoom meetings can help, sure. But after a four-hour Zoomfest, everyone has to admit it's not the same.
For a remote team, written communication is king. But your colleague who can lead an engaging meeting can't necessarily craft an engaging email, or carry a Slack conversation to save his life.
Here at Laskie, we've all been working remote for years. Here's what we learned about communicating well in a long-distance world: our five rules for remote communication, if you will.
Rule #1: Overcommunicate
If you post an important update in your team's group chat, you don't know if everyone's read it. You don't know if everyone understood the consequences. You don't know if they just skimmed it while playing with their dog in the backyard.
You can't communicate something once and expect the team to "get it." Overcommunication means taking those extra steps to ensure everyone is on the same page.
Communicate all important information at least three times. That might mean a public Slack post, an email, and a private Slack conversation with each key stakeholder. Make sure you get actual feedback that people know what you need them to know.
Rule #2: Be concise.
Reading lots of text sucks. On the internet, we've been trained to skim. When people skim, they miss things.
So keep it short. Cut your writing down to just the essential info.
Short, punchy, with high density of information. Not dense like a physics textbook, but dense like your grandma's recipes.
Rule #3: Use the right channel
This rule is also known as "bring back email, but do it right."
For years, chat companies have been trying to convince us email is dead. That's why our spouses and roommates have to suffer through the Slack notification sound every five minutes, right?
Well, email has its place. It's the best way to share information when no discussion is needed. It's easy to search and manage.
But (and this is key) don't forget rule #2. No long emails. Each one should be short, with a clear purpose, and clear next steps.
Some things require a Zoom conversation. Some can be a quick chat message. Others require an email. Pick the right channel for your purpose.
Rule #4: Construct your knowledge base
The fewer conversations someone needs to have to find out what they need to know, the better.
Your team should take what's in their heads and put it in a central location: Google Drive, or Notion, or Confluence, or anything. Build a knowledge base with everyone's combined wisdom.
But there's an art to this. Your employees need to get good at writing and maintaining useful pages. Which leads us to the final, more important rule...
Rule #5: Treat written communication as a skill
Written communication is HARD. It's a whole 'nother ball game, as they say. And it's very, very important, since your team can't do anything if they can't communicate. So invest time in training your team to do it right.
Which leads us to... the sales pitch. Actually, it's not a sales pitch, because we just want to give you something for free.
The take-your-team-to-the-next-level writing guide
We've written a guide on great writing that's perfect for your team.
It's structured as a way for them to become trusted authorities in their company and industry. It's a guide on writing everything, including: essays, emails, Notion pages, and emoji-filled Slack messages.
To get the guide, reply to this email with I WANT MY TEAM TO WRITE BETTER. Or send the same message to firstname.lastname@example.com.
If you know anyone else who might benefit from this guide, forward this email to them. Maybe put something nice at the start, like "I know YOU don't need this, since you're a stellar writer, but perhaps your coworkers do..." They'll like that.
Thanks for reading, and happy writing.


text:
Volunteers prepare supply backpacks to help students
PANAMA CITY - The backpacks going out to Bay District students after Hurricane Michael aren't just filled with school supplies and snacks—in the words of Mercy Chefs Founder and President Greg LeBlanc, "It's filled with love."
Volunteers were busy Thursday and Friday filling the backpacks at Oscar Patterson Elementary School and unloading boxes of supplies. Nearly a year out from Hurricane Michael impacting the area, students are still dealing with the damaged campuses and mental health concerns. Mercy Chefs provided the space.
Some of the volunteers were special needs students from Chautauqua Charter Learn and Serve School. Kelsea Faison, who attends Chautauqua, was busy filling backpacks.
"We came out to help. It feels good to help our community and give back," Faison said. "We learn at Chautauqua to help our community and others."
David Artz, who also attends Chautauqua, said they packed notebooks and pencils. The school Friday was a busy scene as volunteers raced around getting everything together.
"It feels good" to help people, Artz said. "You're doing them a good favor."
Blessings in a Backpack and Vera Bradley also pitched in. Nikki Grizzle, chief marketing officer for Blessings in a Backpack, said 5,000 bags were packed. Blessings in a Backpack provides children with food over the weekends.
"Who doesn't like a brand-new backpack with some great school supplies and snacks?" Grizzle said. "Hopefully we're making these kids' day a little brighter."
Greg Jaeger, director of social media and PR for Vera Bradley—a designer of handbags, luggage and other items--said Friday was exciting.
"It's part of a bigger collaboration we're doing across the country," Jaeger said in reference to working with Blessings in a Backpack. "We heard about the need in this area that's still going on, so we're donating 5,000 backpacks to the area. We're thrilled to be here and do what we can."
Country musician Lauren Alaina, in town to perform at Gulf Coast Jam, dropped by Friday to thank and encourage everyone.
"I'm proud of every person in this room. Shout-out to all of you," Alaina said. "Let's pack these backpacks!"


text:
PPS Kit Midi Size 400ml Micron Filters (25/Case)
In stock
Midi kit contains 50 lids with 125 micron filters, 50 liners and 20 sealing plugs. Graduated measurement to 400 mL (or 13.5 fluid oz) with mix ratio film insert (mix ratio inserts sold separately). For use with part number 16122 Midi Size Cup and Collar. About the new Midi size: You asked for a PPS™ Cup, Lid and Liner that was smaller than our Standard size, but larger than the Mini. 3M is excited to offer the new Midi PPS™ - giving you the most comprehensive range of PPS™ size options for precise, accurate coverage. Ideal for two-panel repairs that require 13.5 fluid ounces of material or less.


text:
Egg & Veggie Muffins, banana, oats, chia & flax seed.
Egg & Veggie Muffins3 eggs
Frozen Mixed Veggies
Paprika (to taste)
2 tbl Almond Milk
Coconut Oil
Preheat oven to 350F.
Grease 12 cup mini muffin pan with coconut oil.
Fill greased muffin cups with frozen mixed veggies.
Whisk together eggs, paprika & almond milk in a bowl, then spooon into muffin cups to rim.
Clean egg shells with soap and water, then break into small pieces.
Top half of the muffin cups with egg shells for your bird.
Bake for 20 minutes.
Use butter knife to loosen muffins. Let cool a few minutes.


text:
To ensure everyone's safety, please note that John R. Park Homestead site will be closed for approximately 3 weeks as shoreline construction and Heritage Centre construction are concurrently underway. The closure during construction hours is anticipated to last approximately 3 weeks.
Service Disruption: temporary construction closure of the John R. Park Homestead
Thursday, October 1, 2020


text:
The Community Champions Fund aims to support Local Authorities and Voluntary Groups to expand their covid communications. The funding will help tackle covid misinformation and encourage up-take of the COVID-19 vaccination over the coming months.
Hyndburn Borough Council have been allocated £492,870 of funding after their successful proposal, the highest amount for any Local Authority in Lancashire.
Cllr Miles Parkinson OBE, Leader of Hyndburn Borough Council said:
"This is an excellent result for Hyndburn. At the end of last year, alongside over 50 other local authorities, we were invited to submit an Expression of Interest for part of the £23 million Community Champions funding, which aims to protect those most at risk of Covid-19. Through consulting with our established community network, we put together a proposal that will make a real difference and I am very pleased to say we were allocated every penny of what we requested."
Plans include strategies to reach those disproportionately affected by the pandemic in Hyndburn, with an aim to improve health and wellbeing for those who need it the most.
Lyndsey Sims, Hyndburn Hub Lead and CEO of Hyndburn Leisure Trust added:
"We were able to confidently bid for such a large amount of funding due to our established relationship with Hyndburn's community and voluntary organisations. Since the start of the pandemic Hyndburn Council, Leisure Trust and HRVCVS have been working side by side to help our community through this difficult time. Under the Hyndburn Hub umbrella there are over 40 organisations who are already doing fantastic, much needed work. The way people have worked together throughout the past 10 months has been exemplary and needs to continue. This funding will be used to empower these existing community champions, harness their expertise and ultimately reduce the impact of Covid-19 in Hyndburn."
The proposal from Hyndburn Borough Council includes various campaigns to increase engagement with key groups such as BAME communities, young people, older adults, homeless people and those with additional needs or disabilities.
Miles continued:
"This will help our borough on the road to recovery and is wonderful news at the start of a difficult year. I would like to thank all those involved in putting the proposal together, our community groups and the hundreds of volunteers for their continued dedication to Hyndburn. This funding has the potential to save lives."
For more information about the funding, awarded please visit:


text:
Universal Disc Player
Elite's brand-new universal disc player brings the spectacle of Ultra HD Blu-ray™ to your home entertainment, with four times the resolution of 1080p Full HD. Featuring three-block internal layout, Ultra Rigid Construction, and Double-Layered Chassis for a robust build, 6-layered main circuit board, SDR/HDR preset mode, and support for HDR10/Dolby Vision for quality picture, as well as premium audio DAC and Zero Signal Terminal for high-grade sound, the UDP-LX500 lets you enjoy the highest video resolution as well as your other digital disc collections.
Three-Block Internal Layout
The blocks for power supply, drive/digital processing, and analog audio are separated into three to eliminate electrical and magnetic interference between the blocks.
Ultra-Rigid Construction without Radiation Holes
Even the holes for heat radiation are excluded to realize a flat form with optimal electric circuit design, and minimum mechanical noise from the rotating system. The result is significantly low noise and even more rigid and stable chassis structure.
Double-Layered Chassis with Rigid Under Base for Rigidity and Low Center of Gravity
The 1.6 mm-thick chassis base is reinforced with a 3 mm-thick steel plate Rigid Under Base. This Double-Layered Chassis structure provides a low center-of-gravity and overall rigidity that prevents the transfer of external vibration to the inner chassis, and offers a superior reading of the disc.
Ultra HD Blu-ray Playback
Ultra HD Blu-ray is the latest disc format with up to 3,840 x 2,160 pixels, four times the resolution of 1080p Full HD. In addition to Ultra HD Blu-ray, the UDP-LX500 is compatible with regular Blu-ray™, DVD, SACD, and audio CD, so you can enjoy the highest video resolution, as well as your digital disc collection on a single disc player.
6-Layered Main Circuit Board for High S/N Ratio
A 6-layered IVH is used for the main circuit board to thoroughly eliminate digital noise. This optimizes the digital signal wiring and minimises GND impedance, and dramatically improves S/N ratio in audio/video signal processing. The 18 Gbps transmission through the latest HDMI standard becomes even more precise.
SDR/HDR Preset Mode for Optimal Performance for the Display
In addition to the video parameter "Reference" for reproducing the original master quality, you can select "LCD TV," "OLED TV," or "Projector"for the video quality best suited to your display. Additionally, there are SDR/HDR presets for each video parameter, that automatically switches between SDR preset and HDR preset according to the output signal.
Disc Information On-Screen Display
You can display the disc information on your screen by pressing and holding the remote control's DISPLAY button. In addition to the playing disc's details, you can easily check mastering information such as MaxFALL (Maximum Frame Average Light Level) and MaxCLL (Maximum Content Light Level) available on some HDR content, as well as HDMI output information .
PQLS Jitter-less Sound Transmission
With the precision quartz controller on a compatible AV receiver, Pioneer's PQLS (Precision Quartz Lock System) eliminates distortion caused by timing errors. It controls the amount of audio signals from the AV receiver to the UDP-LX500, giving the best possible digital-to-analog conversion. UDP-LX500 supports PQLS 2ch Audio, Multi-Surround, and Bit-stream.
Click for more information
Quest For Sound © 2005-2013
Home | PreAmplifiers | Amplifiers | Speakers | Home Theater | Cables | Power | Digital | Analog |
In Home Service | Accessories | Tuners | Repairs at QFS | Our Feedback | Product Lines |
About Us | Contact Us | Demos & "B" Stock Specials | Favorite Links | Policies


text:
Colin Brinsden, AAP Economics Correspondent
(Australian Associated Press)
As punters try to fathom who will win the Melbourne Cup, economists and academics suggest the only clear victors on Tuesday will be borrowers.
While there is a global trend towards higher interest rates as central banks try to normalise their monetary policy settings, after their drastic actions during the 2008-2009 global financial crisis, the Reserve Bank won't be joining in just yet.
The central bank board will hold its monthly meeting on Tuesday and is expected to announce – 30 minutes before Australia's famous horse race – the cash rate remaining at a record low 1.5 per cent, where it has been since August 2016.
But Timo Henckel, a lecturer at the Australian National University's Research School of Economics, says rate rises are looking likely in the future.
"Favourable employment figures and an improving outlook for the global economy increase the likelihood that interest rates need to rise in the future," Dr Henckel said.
Since the October board meeting, the jobless rate fell to 5.5 per cent, and while inflation proved unexpectedly benign, Dr Henckel believes that's likely to be temporary due to a fall in food prices.
New figures on Monday point to a further strengthening in the Australian labour market with job advertisements rising 1.4 per cent in October to be 12 .5 per cent higher than a year earlier.
However, despite strong employment gains in the past year, a much-need pick-up in wages growth remains elusive.
"Even so, we think it reasonable to expect some upward pressure on wages as the labour market tightens," ANZ head of Australian economics David Plank said.
Dr Henckel chairs the ANU's so-called "RBA shadow board", made up of academics, economists and former RBA board members.
The shadow board put a 60 per cent probability of the cash rate remaining at 1.5 per cent this month.
In the longer term, the probability of a rate hike in six months time was 70 per cent.
However, financial markets point to the cash rate remaining unchanged for a lot longer.
"We remain comfortable with our long-held view that the RBA will sit out the rest of 2017 and most of 2018," Commonwealth Bank chief economist Michael Blythe said.
Even then, he expects the central bank to take a cautious approach to further interest rate hikes.


text:
Kimi Raikkonen started his career way back in 1987 and post numerous successes in the Finnish series moved up to compete at international level. Kimi Raikkonen is man of few words, but lets his driving do the talking. He started F1 career with Sauber and make his debut in 2001. He is known for his never-say-die attitude that clinched the 2007 world title for Ferrari and edged in their minds of the fans as the title wasn't decided until the final race of the season in Brazil.
He has gone on to win 21 races and is ranked 15th in the current all-time ranking, one less than Damon Hill and one more than Mika Häkkinen. Raikkonen holds also another impressive stats of hold 103 podiums, which curtails he has stood on the podium in more than 33% of his F1 races. He also is the top five podiums finishers of all time.
Raikkonen holds rare feet of having 46 fastest laps to his credit and is ranked third in the all-time list with only Lewis Hamilton and Michael Schumacher in front of him. Kimi Raikkonen breaks Michael Schumacher's most laps record during the 70th Anniversary Grand Prix at Silverstone. As per official statement Raikkonen has now raced a total of 16,845 laps in his career and he crossed Schumacher's feet, who had raced a total of 16,825 laps in the course of his illustrious career.
As per speculation Kimi Raikkonen is all set to retire from Formula 1 at the end of the season. If the rumours are true, the only person who can beat his record of most distance is Fernando Alonso. Kimi Raikkonen is officially the most experienced driver on the grid post breaking the record for the most miles driven in Formula One history.
Kimi was quoted saying, "I would say it's the first positive day of the whole year for us," said Raikkonen. "Today I could drive the car a bit more like I want. We had the speed. We've been trying as many things as we can come up with, sacrificing some of the qualifying sessions before to just try and learn, and today everything seemed to fall in the right place. Unfortunately, we didn't have any newer sets of soft tyres. We had to use the mediums but we got pretty close even with that. We have to be happy but it's disappointing that we didn't have any more softs – we would have had a chance to go to Q3."