Jun 18, 2019. Your Mac now has additional storage available in Google's cloud to use as you wish. However, one of the best uses of any cloud-based storage system is to link the storage to multiple devices for easy access to synced files with all of your devices: Macs, iPads, iPhones, Windows, and Android platforms. The Mac version of Google's desktop search tool was recently updated to version 1.1, adding support for nine languages (ausgezeichnet!???????) and improving performance.
- Machine Crashes On Svn Update With Google Desktop For Mac Windows 7
- Machine Crashes On Svn Update With Google Desktop For Mac Windows 10
Real-time meetings by Google. Using your browser, share your video, desktop, and presentations with teammates and customers.
Introduction to Programming and C++
This online tutorial continues with more advanced concepts - please read Part III. Our focus in this module will be on using pointers, and getting started with objects.
Learn by Example #2
Our focus in this module is on obtaining more practice with decomposition, understanding pointers, and getting started with objects and classes. Work through the following examples. Write the programs yourself when asked, or do the experiments. We can't emphasize enough that the key to becoming a good programmer is practice, practice, practice!
Example #1: More Decomposition Practice
Consider the following output from a simple game:
The first observation is the introductory text which is displayed once per program execution. We need a random number generator to define the enemy distance for each round. We need a mechanism for getting the angle input from the player and this is obviously in a loop structure since it repeats until we hit the enemy. We also need a function for calculating the distance and angle. Finally, we must keep track of how many shots it took to hit the enemy, as well as how many enemies we havehit during the program execution. Here is a possible outline for the main program.
The Fire procedure handles the playing of the game. In that function, we call a random number generator to get the enemy distance, and then set up the loop to get the player's input and calculate whether or not they have hit the enemy. The guard condition on the loop is how close we have gotten to hitting the enemy.
Because of the calls to cos() and sin(), you will need to include math.h. Try writing this program - it's great practice in problem decomposition and a good review of basic C++. Remember to only do one task in each function. This is the most sophisticated program we have written thus far, so it may take you a little time to do it. Here is our solution.
Example #2: Practice with Pointers
There are four things to remember when working with pointers:- Pointers are variables that hold memory addresses. As a program is executing, all variables are stored in memory, each at its own unique address or location. A pointer is a special type of variable that contains a memory address rather than a data value. Just as data is modified when a normal variable is used, the value of the address stored in a pointer is modified as a pointer variable is manipulated. Here's an example:
- We usually say that a pointer 'points' to the location it is storing (the 'pointee'). So in the example above, intptr points to the pointee 5.
Notice the use of the 'new' operator to allocate memory for our integer pointee. This is something we must do before trying to access the pointee.
The * operator is used for dereferencing in C. One of the most common errors C/C++ programmers make in working with pointers is forgetting to initialize the pointee. This can sometimes cause a runtime crash because we are accessing a location in memory that contains unknown data. If we try and modify this data, we can cause subtle memory corruption making it a hard bug to track down.
- Pointer assignment between two pointers makes them point to the same pointee. So the assignment y = x; makes y point to the same pointee as x. Pointer assignment does not touch the pointee. It just changes one pointer to have the same location as another pointer. After pointer assignment, the two pointers 'share' the pointee.
Here is a trace of this code:
| 1. Allocate two pointers x and y. Allocating the pointers does not allocate any pointees. |
| 2. Allocate a pointee and set x to point to it. |
| 3. Dereference x to store 42 in its pointee. This is a basic example of the dereference operation. Start at x, follow the arrow over to access its pointee. |
| 4. Try to dereference y to store 13 in its pointee. This crashes because y does not have a pointee -- it was never assigned one. |
| 5. Assign y = x; so that y points to x's pointee. Now x and y point to the same pointee -- they are 'sharing'. |
| 6. Try to dereference y to store 13 in its pointee. This time it works, because the previous assignment gave y a pointee. |
As you can see, pictures are very help in understanding pointer usage. Here is another example.
Notice in this example that we never allocated memory with the 'new' operator. We declared a normal integer variable and manipulated it via pointers.
In this example, we illustrate the use of the delete operator which de-allocates heap memory, and how we can allocate for more complex structures. We will cover memory organization (heap and runtime stack) in the another lesson. For now, just think of the heap as a free store of memory available to running programs.
In this final example, we show how pointers are used to pass values by reference to a function. This is how we modify the values of variables within a function.
If we were to leave the &'s off the arguments in the Duplicate function definition, we pass the variables 'by value', i.e., a copy is made of the value of the variable. Any changes made to the variable in the function modify the copy. They do not modify the original variable.
When a variable is passed by reference we are not passing a copy of its value, we are passing the address of the variable to the function. Any modification that we do to the local variable actually modifies the original variable passed in.
If you are a C programmer, this is a new twist. We could do the same in C by declaring Duplicate(int *x), in which case Duplicate() with argument x), and using de-referencing of Duplicate() (see below). But C++ provides a simpler way of passing values to functions by reference, even though the old 'C' way of doing it still works.
Notice with C++ references, we do not need to pass the address of a variable, nor do we need to dereference the variable inside the called function.
What does the following program output? Draw a picture of memory to figure it out.
Run the program to see if you got the correct answer.
Example #3: Passing Values by Reference
Write a function called accelerate() that takes as input the speed of a vehicle, and an amount. The function adds the amount to the speed to accelerate the vehicle. The speed parameter should be passed by reference, and amount by value. Here is our solution.
Example #4: Classes and Objects
Consider the following class:
Notice that class member variables have a trailing underscore. This is done to differentiate between local variables and class variables.
Add a decrement method to this class. Here is our solution.
The wonders of Science: Computer Science
Exercises
As in the first module of this course, we do not provide solutions to exercises and projects.
Remember That a Good Program..
.. is decomposed logically into functions where any one function does one and only one task.
.. has a main program that reads like an outline of what the program will do.
.. has descriptive function, constant and variable names.
.. uses constants to avoid any 'magic' numbers in the program.
.. has a friendly user interface.
Warm-up Exercises
- Exercise 1
The integer 36 has a peculiar property: it is a perfect square, and is also the sum of the integers from 1 through 8. The next such number is 1225 which is 352, and the sum of the integers from 1 through 49. Find the next number that is a perfect square and also the sum of a series 1..n. This next number may be greater than 32767. You may use library functions that you know of, (or mathematical formulas) to make your program run faster. It is also possible to write this program using for-loops to determine if a number is a perfect square or a sum of a series. (Note: depending on your machine and your program, it can take quite a while to find this number.)
- Exercise 2
Your college book store needs your help in estimating its business for next year. Experience has shown that sales depend greatly on whether a book is required for a course or just optional, and whether or not it has been used in the class before. A new, required textbook will sell to 90% of prospective enrollment, but if it has been used in the class before, only 65% will buy. Similarly, 40% of prospective enrollment will buy a new, optional textbook, but if it has been used in the class before only 20% will buy. (Note that 'used' here does not mean second-hand books.)
Write a program that accepts as input a series of books (until the user enters a sentinel). For each book ask for: a code for the book, the single copy cost for the book, the current number of books on hand, the prospective class enrollment, and data that indicates if the book is required/optional, new/used in past. As output, show all the input information in a nicely formatted screen along with how many books must be ordered (if any, note that only new books are ordered), the total cost of each order.
Best screensavers for mac. Then, after all input is complete, show the total cost of all book orders, and the expected profit if the store pays 80% of list price. Since we have not yet discussed any ways of dealing with a large set of data coming into a program (stay tuned!), just process one book at a time and show the output screen for that book. Then, when the user has finished entering all the data, your program should output the total and profit values.
Before you start writing code, take some time to think about design of this program. Decompose into a set of functions, and create a main() function that reads like an outline for your solution to the problem. Make sure each function does one task.
Here is sample output:
Database Project
In this project, we create a fully functional C++ program that implements a simpledatabase application.
Our program will allow us to manage a database of composers and relevant information about them. The features of the program include:
- The ability to add a new composer
- The ability to rank a composer (i.e., indicate how much we like or dislike the composer's music)
- The ability to view all the composers in the database
- The ability to view all composers by rank
'There are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult.' - C.A.R. Hoare
Many of us learned to design and code using a 'procedural' approach. The central question we begin with is 'What must the program do?'. We decompose the solution to a problem into tasks, each of which solves a part of the problem. These tasks map to functions in our program which are called sequentially from main() or from other functions. This step-by-step approach is ideal for some problems we need to solve. But more often than not, our programs are not just linear sequences of tasks or events.
With an object-oriented (OO) approach, we start with the question 'What real-world objects am I modeling?' Instead of dividing a program into tasks as described above, we divide it into models of physical objects. These physical objects have a state defined by a set of attributes, and a set of behaviors or actions that they can perform. The actions might change the state of the object, or they might invoke actions of other objects. The basic premise is that an object 'knows' how to do things by itself.
In OO design, we define physical objects in terms of classes and objects; attributes and behaviors. There are generally a large number of objects in an OO program. Many of these objects, however, are essentially the same. Consider the following.
A class is a set of general attributes and behaviors for an object, which may exist physically in the real world. In the illustration above, we have an Apple class. All apples, regardless of their type, have color and taste attributes. We have also defined a behavior whereby the Apple displays its attributes.In this diagram, we have defined two objects which are of the Apple class. Each object has the same attributes and actions as the class, but the object defines the attributes for a specific type of apple. In addition, the Display action displays the attributes for that particular object, e.g., 'Green' and 'Sour'.
An OO design consists of a set of classes, the data associated with these classes, and the set of actions the classes can perform. We also need to identify the ways different classes interact. This interaction can be performed by objects of a class invoking the actions of objects of other classes. For example, we could have a AppleOutputer class that outputs the color and taste of an array of Apple objects, by calling the Display() method of each Apple object.
Here are the steps we perform in doing OO design:
- Identify the classes, and define in general what an object of each class stores as data and what an object can do.
- Define the data elements of each class
- Define the actions of each class and how some actions of one class can be implemented using actions of other related classes.
For a large system, these steps occur iteratively at different levels of detail.
For the composer database system, we need a Composer class which encapsulates all the data we want to store on an individual composer. An object of this class can promote or demote itself (change its rank), and display its attributes.
We also need a collection of Composer objects. For this, we define a Database class which manages the individual records. An object of this class can add or retrieve Composer objects, and display individual ones by invoking the display action of a Composer object.
Finally, we need some kind of user interface to provide interactive operations on the database. This is a placeholder class, i.e., we really don't know what the user interface is going to look like yet, but we do know we will need one. Maybe it will be graphical, maybe text-based. For now, we define a placeholder which we can fill in later.
Now that we have identified the classes for the composer database application, the next step is to define the attributes and actions for the classes. In a more complex application, we would sit down with pencil and paper or UML or CRC cards or OOD to map out the class hierarchy and how the objects interact.
For our composer database, we define a Composer class which contains the relevant data we want to store on each composer. It also contains methods for manipulating rankings, and displaying the data.
The Database class needs some kind of structure for holding Composer objects. We need to be able to add a new Composer object to the structure, as well as retrieve a specific Composer object. We'd also like to display all the objects either in order of entry, or by ranking.
The User Interface class implements a menu-driven interface, with handlers that call actions in the Database class.
If the classes are easily understood and their attributes and actions clear, as in the composer application, it's relatively easy to design the classes. But if there are any questions in your mind as to how the classes relate and interact, it's best to draw it out first, and work through the details before starting to code.
Once we have a clear picture of the design and have evaluated it (more on this soon), we define the interface for each class. We don't worry about implementation details at this point - just what are the attributes and actions, and what parts of a class' state and actions are available to other classes.
In C++, we normally do this by defining a header file for each class. The Composer class has private data members for all the data we want to store on a composer. We need accessors ('get' methods) and mutators ('set' methods), as well as the primary actions for the class.
The Database class is straight-forward as well.
Notice how we have carefully encapsulated the composer-specific data in a separate class. We could have put a struct or class in the Database class to represent the Composer record, and accessed it directly there. But that would be 'under-objectification', i.e., we are not modeling with objects as much as we could.
You'll see as you start to work on the implementation of the Composer and Database classes, that it is much cleaner to have a separate Composer class. In particular, having separate atomic operations on a Composer object greatly simplify the implementation of the Display() methods in the Database class.
Of course, there is also such a thing as 'over-objectification' where we try and make everything a class, or we have more classes than we need. It takes practice to find the right balance, and you'll find that individual programmers will have differing opinions.
Determining if you are over- or under-objectifying can often be sorted out by carefully diagramming your classes. As mentioned earlier, it's important to work out a class design before you start coding and this can help you analyze your approach. A common notation used for this purpose is UML (Unified Modeling Language) Now that we have the classes defined for the Composer and Database objects, we need an interface that allows the user to interact with the database. A simple menu will do the trick:
We could implement the user interface as a class, or as a procedural program. Not everything in a C++ program has to be a class. In fact, if the processing is sequential or task-oriented, as in this menu program, it's fine to implement it procedurally. It's important to implement it in such a way that it remains a 'placeholder', i.e., if we want to create a graphical user interface at some point, we should not have to change anything in the system but the user interface.
The last thing we need to complete the application is a program to test the classes. For the Composer class, we want a main() program that takes input, populates a composer object and then displays it to make sure the class is working properly. We also want to call all the methods of the Composer class.
We need a similar test program for the Database class.
Note that these simple test programs are a good first step, but they require us to manually inspect the output to be sure the program is working correctly. As a system gets larger, manual inspection of output rapidly becomes impractical. In a subsequent lesson, we'll introduce self-checking test programs in the form of unit tests.
The design for our application is now complete. The next step is to implement the .cpp files for the classes and the user interface. To start, go ahead and copy/paste the .h and test driver code above into files, and compile them. Use the test drivers to test your classes. Then, implement the following interface:
Use the methods you defined in the Database class to implement the user interface. Make your methods error-proof. For example, a ranking should always be in the range 1-10. Don't let anyone add 101 composers either, unless you plan to change the data structure in the Database class.
Remember - all your code needs to follow our coding conventions, which are repeated here for your convenience:
- Every program we write begins with a header comment, providing the name of the author, their contact information, a short description, and usage (if relevant). Every function/method begins with a comment on operation and usage.
- We add explanatory comments using full sentences, whenever the code does not document itself, for example, if the processing is tricky, non-obvious, interesting, or important.
- Always use descriptive names: variables are lower-case words separated by _, as in my_variable. Function/method names use upper-case letters to mark words, as in MyExcitingFunction(). Constants start with a 'k' and use upper-case letters to mark words, as in kDaysInWeek.
- Indentation is in multiples of two. The first level is two spaces; if further indentation is needed, we use four spaces, six spaces, etc.
Welcome to the Real World!
In this module, we introduce two very important tools used in most software engineeringorganizations. The first is a build tool, and the second is a configuration managementsystem. Both of these tools are essential in industrial software engineering, wheremany engineers often work on one large system. These tools help to coordinate andcontrol changes to the code base, and provide an efficient means for compilingand linking a system from many program and header files.
Makefiles
The process of building a program is usually managed with a build tool, which compiles and links the required files, in the correct order. Quite often, C++ files have dependencies, for example, a function called in one program resides in another program. Or, perhaps a header file is needed by several different .cpp files. A build tool figures out the correct compile order from these dependencies. It will also only compile files that have changed since the last build. This can save a lot of time in systems consisting of several hundreds or thousands of files.
An open source build tool called make is commonly used. To learn about it, read through this article. See if you can create a dependency graph for the Composer Database application, and then translate this into a makefile. Here is our solution.
Configuration Management Systems
The second tool used in industrial software engineering is Configuration Management (CM). This is used to manage change. Let's say Bob and Susan are both tech writers and both are working on updates to a technical manual. During a meeting, their manager assigns them each a section of the same document to update.
The technical manual is stored on a computer that both Bob and Susan can access. Without any CM tool or process in place, a number of problems could arise. One possible scenario is the computer storing the document might be set up so that Bob and Susan can not both work on the manual at the same time. This would slow them down considerably.
A more dangerous situation arises when the storage computer does allow the document to be opened by both Bob and Susan at the same time. Here is what could happen:
- Bob opens the document on his computer and works on his section.
- Susan opens the document on her computer and works on her section.
- Bob completes his changes and saves the document on the storage computer.
- Susan completes her changes and saves the document on the storage computer.
This illustration shows the problem that can occur if there are no controls on the single copy of the technical manual. When Susan saves her changes, she overwrites those made by Bob.
This is exactly the type of situation that a CM system can control. With a CM system, both Bob and Susan 'check out' their own copy of the technical manual and work on them. When Bob checks his changes back in, the system knows that Susan has her own copy checked out. When Susan checks in her copy, the system analyzes the changes that both Bob and Susan made and creates a new version that merges the two sets of changes together.
CM systems have a number of features beyond managing concurrent changes as described above. Many systems store archives of all versions of a document, from the first time it was created. In the case of a technical manual, this can be very helpful when a user has an old version of the manual and is asking a tech writer questions. A CM system would allow the tech writer to access the old version and be able to see what the user is seeing.
CM systems are especially useful in controlling changes made to software. Such systems are called Software Configuration Management (SCM) systems. If you consider the huge number of individual source code files in a large software engineering organization and the huge number of engineers who must make changes to them, it's clear that an SCM system is critical.
Software Configuration Management
SCM systems are based on a simple idea: the definitive copies of your files are kept in a central repository. People check out copies of files from the repository, work on those copies, and then check them back in when they are finished. SCM systems manage and track revisions by multiple people against a single master set.
All SCM systems provide the following essential features:
- Concurrency Management
- Versioning
- Synchronization
Let's look at each of these features in more detail.
Concurrency Management
Concurrency refers to the simultaneous editing of a file by more than one person. With a large repository, we want people to be able to do this, but it can lead to some problems.
Consider a simple example in the engineering domain: Suppose we allow engineers to modify the same file simultaneously in a central repository of source code. Client1 and Client2 both need to make changes to a file at the same time:
- Client1 opens bar.cpp.
- Client2 opens bar.cpp.
- Client1 changes the file and saves it.
- Client2 changes the file and saves it overwriting Client1's changes.
Obviously, we don't want this to happen. Even if we controlled the situation by having the two engineers work on separate copies instead of directly on a master set (as in the illustration below), the copies must somehow be reconciled. Most SCM systems deal with this problem by allowing multiple engineers to check a file out ('sync' or 'update') and make changes as needed. The SCM system then runs algorithms to merge the changes as files are checked back in ('submit' or 'commit') to the repository.
These algorithms can be simple (ask the engineers to resolve conflicting changes) or not-so-simple (determine how to merge the conflicting changes intelligently and only ask an engineer if the system really gets stuck).
Versioning
Versioning refers to keeping track of file revisions which makes it possible to re-create (or roll back to) a previous version of the file. This is done either by making an archive copy of every file when it is checked into the repository, or by saving every change made to a file. At any time, we can use the archives or change information to create a previous version. Versioning systems can also create log reports of who checked in changes, when they were checked in, and what the changes were.
Synchronization
With some SCM systems, individual files are checked in and out of the repository. More powerful systems allow you to check out more than one file at a time. Engineers check out their own, complete, copy of the repository (or part thereof) and work on files as needed. They then commit their changes back to the master repository periodically, and update their own personal copies to stay up-to-date with changes other people have made. This process is called syncing or updating.
Subversion
Subversion (SVN) is an open-source version control system. It has all of the features described above.
SVN adopts a simple methodology when conflicts occur. A conflict is when two or more engineers make different changes to the same area of the code base and then both submit their changes. SVN only alerts the engineers that there is a conflict - it's up to the engineers to resolve it.
We are going to use SVN throughout this course to help you become familiar with configuration management. Such systems are very common in industry.
The first step is to install SVN on your system. Click here for instructions. Find your operating system and download the appropriate binary.
Some SVN Terminology
- Revision: A change in a file or set of files. A revision is one 'snapshot' in a constantly changing project.
- Repository: The master copy where SVN stores a project's full revision history. Each project has one repository.
- Working Copy: The copy in which an engineer make changes to a project. There can be many working copies of a given project each owned by an individual engineer.
- Check Out: To request a working copy from the repository. A working copy equals the state of the project when it was checked out.
- Commit: To send changes from your working copy into the central repository. Also known as check-in or submit.
- Update: To bring others' changes from the repository into your working copy, or to indicate if your working copy has any uncommitted changes. This is the same as a sync, as described above. So, update/sync brings your working copy up-to-date with the repository copy.
- Conflict: The situation when two engineers try to commit changes to the same area of a file. SVN indicates conflicts, but the engineers must resolve them.
- Log message: A comment you attach to a revision when you commit it, which describes your changes. The log provides a summary of what's been going on in a project.
Now that you have SVN installed, we'll run through some basic commands. The first thing to do is set up a repository in a specified directory. Here are the commands:
The import command copies the contents of directory mytree into the directory project in the repository. We can take a look at the directory in the repository with thelist command
The import does not create a working copy. To do this, you need to use the svn checkout command. This creates a working copy of the directory tree. Let's do that now:
Now that you have a working copy, you can make changes to the files and directories there. Your working copy is just like any other collection of files and directories - you can add new ones or edit them, move them around, you can even delete the entire working copy. Note that if you copy and move files in your working copy, it is important to use svn copy and svn move instead of your operating system commands. To add a new file, use svn add and to delete a file use svn delete. If all you want to do is edit, just open the file with your editor and edit away!
There are some standard directory names often used with Subversion. The 'trunk' directory holds the main line of development for your project. A 'branches' directory holds any branch version you might be working on.
So, let's say you have made all the required changes to your working copy and you want to sync it with the repository. If a lot of other engineers are working in this area of the repository, it's important to keep your working copy up-to-date. You can use the svn status command to view the changes that you have made.
Note that there are lots of flags on the status command to control this output. If you'd like to view the specific changes in a modified file, use svn diff.
Finally, to update your working copy from the repository, use the svn update command.
This is one place where a conflict might occur. In the output above, the 'U' indicates no changes were made to the repository versions of these files and an update was done. The 'G' means a merge occurred. The repository version had been changed, but the changes did not conflict with yours. The 'C' indicates a conflict. This means that the changes from the repository overlapped with yours, and now you have to choose between them.
For every file that has a conflict, Subversion puts three files in your working copy:
- file.mine: This is your file as it existed in your working copy before you updated your working copy.
- file.rOLDREV: This is the file you checked out of the repository prior to making your changes.
- file.rNEWREV: This file is the current version in the repository.
You can do one of three things to resolve the conflict:
- Go through the files and do the merge manually.
- Copy one of the temporary files created by SVN over your working copy version.
- Run svn revert to throw away all of your changes.
Once you've resolved the conflict, you let SVN know by running svn resolved. This removes the three temporary files and SVN no longer views the file in a conflict state.
The last thing to do is to commit your final version to the repository. This is done with the svn commit command. When you commit a change, you need to provide a log message, which describes your changes. This log message is attached to the revision you create.
There is so much more to learn about SVN, and how it can support large software engineering projects. There are extensive resources available on the web - just do a Google search on 'Subversion'.
For practice, create a repository for your Composer Database system, and import all of your files. Then checkout a working copy and go through the commands described above.
References
Application: A Study in Anatomy
Check out eSkeletons from The University of Texas at Austin
Firefox 3 Release Notes
v3.0.12, released July 21, 2009 Check out what's new, the known issues and frequently asked questions about the latest version of Firefox. As always, you're encouraged to tell us what you think, either using this feedback form or by filing a bug in Bugzilla.
What's New in Firefox 3.0.12
Firefox 3.0.12 fixes several issues found in Firefox 3.0.11:
- Fixed several security issues.
- Fixed several stability issues.
- Fixed an issue introduced in Firefox 3.0.11, where Firefox would occasionally freeze when accessing the Java plug-in on Windows XP. (bug 498132)
- Fixed an issue introduced in Firefox 3.0.11, where Firefox would not save data properly when a user stored their home directory on a remote location using AFP. (bug 497792)
- On Mac OS X, fixed an issue where certain AppleScripts failed to return the proper information. (bug 427448)
- See the Firefox 3.0.11 release notes for changes in previous releases.
See the complete list of bugs fixed.
System Requirements
Before installing, make sure your computer meets the system requirements.
Downloading
Mozilla provides Firefox 3 for Windows, Linux, and Mac OS X in a variety of languages. You can get the latest version of Firefox 3 here. For builds for other systems and languages not provided by Mozilla.org, see the Contributed Builds section at the end of this document.
Installing
Please note that installing Firefox 3 will overwrite your existing installation of Firefox. You won't lose any of your bookmarks or browsing history, but some of your extensions and other add-ons might not work until updates for them are made available.
Uninstalling
You can remove Firefox 3 through the Control Panel in the Start Menu on Windows, by removing the Firefox application on OS X, or by removing the firefox folder on Linux.
Removing Firefox 3 won't remove your bookmarks, web browsing history, extensions or other add-ons. This data is stored in your profile folder, which is located in one of the following locations depending on your operating system:
| Windows Vista | UsersAppDataRoamingMozillaFirefox |
| Windows 2000, XP, Server 2003 | Documents and SettingsApplication DataMozillaFirefox |
| Mac OS X | ~/Library/Application Support/Firefox |
| Linux and Unix systems | ~/.mozilla/firefox |
Any version of Firefox that you install after removing Firefox 3 will continue to use the data from this profile folder.
Extensions and Themes
Extensions installed under Firefox 2 may be incompatible and/or require updates to work with Firefox 3. Please report any issues to the maintainer of the extension. When you install Firefox 3 all of your Extensions and Themes will be disabled until Firefox 3 determines that either a) they are compatible with the Firefox 3 release or b) there are newer versions available that are compatible.
Known Issues
This list covers some of the known problems with Firefox 3. Please read this before reporting any new bugs.
Machine Crashes On Svn Update With Google Desktop For Mac Windows 7
- If Flash content is active when Firefox crashes, the Crash Reporter may not activate (bug 422308). This issue is fixed in Flash 10.
- Deleting an entry from the history sidebar, then invoking the Clear Private Data tool can result Firefox crashing (bug 426275)
- Some add-ons that depend on deprecated code may not install properly (see bug 406807)
- Privacy > History > Remember visited pages to '0' has no effect (bug 366075)
- Some Web pages (such as mlb.com) do not properly detect if Silverlight is installed and will not function properly (bug 432371) This issue is fixed by the Silverlight 2.0 beta.
- The DOM Inspector has been removed and is now available as an add-on.
- Support for Cross-Site XmlHttpRequest has been removed until the specification becomes more stable and the security model is improved (bug 424923)
- After dismissing the 'Do you want Firefox to remember this password' prompt, it is sometimes not possible to focus form fields unless you reload the page (bug 433942)
- The new Location Bar, Add Bookmark dialog, and Download Manager information popup behave inconsistently with Window-Eyes (bug 393398). This is fixed in an upcoming Window-Eyes release.
- A Windows Media Player (WMP) plugin is not provided with Windows Vista and some other versions of Windows. To view Windows Media content, you must install this plugin by following these instructions. After installing you may need to check for Windows Updates before the plugin will show content properly.
- Users who have older installations of Google Desktop Search may experience crashes on startup; reinstalling Google Desktop Search fixes the problem (bug 401513)
- If you are using IPv6 from a network location that doesn't support IPv6 routing your DNS lookups may be very slow. Set network.dns.disableIPv6 to true as a workaround (bug 417689)
- Users running Ubuntu 7.10 may need to update their certificate databases in order to submit crash reports (bug 407748 for instructions)
- The mouse button assignments for Back and Forward have changed, users may need to reconfigure their pointing devices (bug 420294)
- Incompatibilities between NVIDIA drivers and some versions of the X server cause scaled images to render incorrectly (bug 411831)
- The Orca screen reading software does not read some text, such as the save password notification, site identity information, or the default prompt text in search fields - these are known problems with Orca (see Gnome bug 533109 and 533125). This issue will be fixed in an upcoming Orca release.
Troubleshooting
- Poorly designed or incompatible extensions can cause problems with your browser, including make it crash, slow down page display, etc. If you encounter strange problems relating to parts of the browser no longer working, the browser not starting, windows with strange or distorted appearance, degraded performance, etc, you may be suffering from Extension or Theme trouble. Restart the browser in Safe Mode. On Windows, start using the 'Safe Mode' shortcut created in your Start menu or by running
firefox.exe -safe-mode. On Linux, start with./firefox -safe-modeand on Mac OS X, run:
When started in Safe Mode all extensions are disabled and the Default theme is used. Disable the Extension/Theme that is causing trouble and then start normally.cd /Applications/Firefox.app/Contents/MacOS/
./firefox-bin -safe-mode - If you uninstall an extension that is installed with your user profile (i.e. you installed it from a Web page) and then wish to install it for all user profiles using the -install-global-extension command line flag, you must restart the browser once to cleanse the profile extensions datasource of traces of that extension before installing with the switch. If you do not do this you may end up with a jammed entry in the Extensions list and will be unable to install the extension globally.
- If you encounter strange problems relating to bookmarks, downloads, window placement, toolbars, history, or other settings, it is recommended that you try creating a new profile and attempting to reproduce the problem before filing bugs. Create a new profile by running Firefox with the -P command line argument, choose the 'Manage Profiles' button and then choose 'Create Profile..'. Migrate your settings files (Bookmarks, Saved Passwords, etc) over one by one, checking each time to see if the problems resurface. If you do find a particular profile data file is causing a problem, file a bug and attach the file.
Frequently Asked Questions
- What can I do to help?
We need help from developers and the testing community to provide as much feedback as possible to make Firefox even better. Please read these notes and the bug filing instructions before reporting any bugs to Bugzilla. You can also give us your feedback through this feedback form.
- Why haven't you responded to the mail I sent you?
Use the newsgroup. The Firefox team reads it regularly, and your email may have gotten lost.
- Where can I get extensions and themes (add-ons)?
Extensions and Themes can be downloaded from Firefox Add-ons.
- Who makes Firefox 3?
Lots of people. See Help->About Mozilla Firefox, Credits for a list of some of the people who have contributed to Firefox 3.
- Where's the Firefox 3 source code?
A tarball of the Firefox 3 source code is available for download. The latest development code can be obtained by cvs. Firefox-specific source is in 'mozilla/browser', 'mozilla/toolkit', and 'mozilla/chrome'. Please follow the build instructions.
- Where is the mail client?
Firefox 3 works with whatever mail client is the default on your system. However, we recommend Mozilla Thunderbird, our next-generation email client and the perfect complement to Firefox.
Machine Crashes On Svn Update With Google Desktop For Mac Windows 10
Contributed Builds
These are unofficial builds and may be configured differently than the official Mozilla builds. They may also be optimized and/or tested for specific platforms. You can browse through the available contributed builds on the FTP site.
Other Resources and Links
The following resources contain useful information about Firefox 3:
- SafeBrowsing Service Privacy Policy (for anti-phishing/anti-malware feature)
