Picking Up The Pieces Mac OS

• Picking Up The Pieces Mac Os 11
• Picking Up The Pieces Mac Os X
• Picking Up The Pieces Mac Os Download

Mac Won't Recognize USB, What Should You Do?

Today is the 20th anniversary of the launch of Mac OS X, and Macworld has an interesting piece on the history leading up to it. Jason Snell goes so far as to say that the new operating system for. Pick up any Mac, and it will function the same as the others — with some caveats. Thanks to macOS, there will be little to no difference between how a desktop and laptop perform. Officially, the operating system that was available on that Mac at the time that you bought it is the oldest version of macOS that can run on that Mac. It's likely that an older OS won't include.

Commonly, when you insert a USB drive in the USB port on a Mac computer, the drive will soon appear on the desktop or hide in the Finder, letting you access, view, and manage data on it. Did you come across the situation that no matter how many times you try to connect the USB drive with a Mac computer, the USB drive is not showing up anywhere? Why this time Mac won't recognize a connected USB you may wonder. Though not a usual thing, the issue of an external hard drive or flash drive not showing up on Mac happens sometimes. What should you do in this circumstance? What are the effective solutions to make your USB drive show up again?

This page basically covers all the possible fixes for USB not showing up on Mac, which also applies to the similar issues of other storage devices like an external hard drive not showing up on Mac, flash drive not showing up on Mac, SD card not showing up on Mac, etc. Take a quick glance at the main content and directly jump to the part you're most interested in.

10 Fixes for USB Not Showing Up on Mac

The reasons behind the problem of a USB device not showing up are various, including the USB port is not working, USB drive corruption, virus infection, macOS faulty, etc. So, to figure out the effective solutions for your own case, you need to take time to have some basic check, exclude the irrelevant issues, identify the potential risk, and finally solve it!

Fix 1. Change the USB-to-Mac connection way

Have you tried to restart your Mac once or twice? Before taking further measures, don't forget the most efficient way to tackle commonplace hardware glitches that arises from time to time. If this operating system restarting fails to solve the current problem, move on to check the physical connectivity issue step by step.

Step 1. Plug the USB drive out from the not working USB port and change to the other USB port. Try all the available USB ports on your Mac.

Step 2. Did you use a USB connection cable or a USB-C adapter? If yes, take the USB drive out, and directly plug it in the USB port.

Step 3. Is there the other Mac computer available to you? If yes, try to connect the USB drive to this computer. Is it showing up normally?

Step 4. For SD card owners, the common way to connect an SD card to a Mac needs a card reader. If changing the USB ports did not work, try to change a card reader for a new round of tests.

The four steps of troubleshooting a USB drive not showing up on Mac are very basic, however, quite helpful in most cases. Each step can help us exclude the issues of a bad/loose connection, a not working USB port, a lack of power, and other superficial phenomenons.

Fix 2. Change settings for Mac detecting an external hard disk on the desktop

Occasionally, your Mac has already recognized the USB flash drive but not shown it on the desktop. Thus, you should go to Finder > Preferences > General and make sure the 'External disks' option is ticked. Then you'll see the USB flash drive showing up on Mac desktop.

Fix 3. Change settings for Mac recognize an external hard disk in the Finder

Finder is the other access for us to check a connected external drive on Mac. If your flash drive or external hard drive is not showing up there, go to Finder > Preferences > Sidebar, and under Locations, you need to tick the option 'External disks'. By selecting this option, we can make sure that the connected external USB hard drive or flash drive will normally show up in the Finder.

Fix 4. Check the USB drive in System Information

When you cannot find the USB drive on the desktop or in the Finder, try to look for it in the System Information section, which is usually a hidden place for average Mac users.

Step 1. Go to Applications > Utilities > System Information.

Step 2. Check if the system detects the USB drive. Click 'USB' on the left panel, and you can also check the USB flash drive information.

Fix 5. Reset USB ports on Mac to detect a USB drive

Step 1. Restart Mac computer, press the Command +Option+P+R keys until the Apple logo appears.

Step 2. Press Command+Option+Esc keys to close all applications that are not responding.

Step 3. Plug the USB which is not showing up to your Mac computer. If it doesn't show up, click Apple icon and select 'Sleep'.

Step 4. Wake up the computer after a few seconds by pressing any key.

Step 5. Shut down the Mac, unplug the power cord, reattach it after 15 seconds.

If this doesn't work, we should suspect the corruption issue at this moment. Don't give up and try to do some repair by yourself.

Fix 6. Repair USB flash drive with First Aid if it doesn't show up

Step 1. Go to Applications > Utilities > Disk Utility.

1. Step 2. Select USB flash drive on the left panel of Disk Utility, and click 'First Aid' at the top toolbar and click 'Run'. Disk Utility will repair any errors on the drive automatically.

Step 3. Select the USB drive and click 'Unmount' at the top toolbar, unplug the USB and plug it back in 10-15 seconds.

Fix 7. Check and fix errors in a not recognized USB with Terminal

Step 1. Open Terminal in Utilities, type:diskutil list and press Return.

Step 2. Find the disk number of your USB flash drive, type: diskutil info disk2 and press Return. (Replace 2 with the disk number of your USB flash drive.)

Step 3. Type: diskutil eject disk 2 and press Return.

Step 4. Type: diskutil list and press Return.When the USB disappear from the Terminal list, close the window.

Step 5. Close Terminal and open Console to inspect your drive errors.

Step 6. Click 'Errors and Faults' to check if there are any errors.

Step 7. Reconnect your USB flash drive back to Mac, if no error shows up, your USB flash drive is safe.

Fix 8. Save data and reformat the not showing USB drive

Disk reformatting basically solves many hard drive issues, including the not showing up USB, particularly the time when you are able to see the USB icon but files are not showing. USB drive showing empty makes no sense, so you have to reformat the disk and make it usable again.

Note that reformatting will erase data. As long as the data matters, you need to follow the standard procedure to ensure zero data loss. [1] Download EaseUS Data Recovery Wizard for Mac, the professional Mac data recovery software, to perform a full USB drive data recovery. [2] Reformat the USB drive in Disk Utility.

To format the USB drive in Disk Utility:

Step 1. Go to Utilities and open Disk Utility.

Step 2. Select the not showing up USB flash drive in the Disk Utility sidebar.

Step 3. Click Erase on the top.

Step 4. Finish the necessary information (name, format, and scheme) to format the USB flash drive.

Fix 9. Update your macOS and firmware

Did your Mac's OS keep updating all the time? Chances are that your Mac won't recognize a USB drive, especially after a macOS update. This time, take a close look at the settings whether your Mac is up-to-date. Equally, firmware updates address a variety of hardware issues and the functionality of the USB ports could well be one of them. So, keep your software and firmware up to date will likely make the USB drive show up as normal again.

Fix 10. Send the USB drive to a repair center

Nowadays even the branded USB flash drives are not expensive. If you've tried all the suggested troubleshooting methods, the USB drive is still not showing up on Mac, you have to accept the truth that it's severely damaged and beyond your ability to repair it.

Mac won't recognize a badly damaged flash drive or external hard drive since there is no way to show it up, even temporarily, which makes the data recovery difficult. The last chance for you to rescue data is to send the broken USB drive to a specialized data recovery service center nearby, and let the professionals try their best. You need to prepare for the manual data recovery cost, which is noticeably higher than the software data recovery. Hence, always try the cost-effective plan of using EaseUS Data Recovery Wizard to scan the USB drive for the first attempt.

Step 1. Correctly connect your USB flash drive to your Mac. Launch EaseUS Data Recovery Wizard for Mac. Start selecting the flash drive and click 'Scan' to let the software search lost files on it.

Step 2. After a quick scan and deep scan, all files will be presented in the left panel in the scan results.

Step 3. Select files you want to recover and click the 'Recover Now' button. Don't save the recoverable files to the USB drive itself in case of data overwriting.

Take Action to Make Your USB Recognized Again

On this page, we collected 10 practical fixes for you to repair not recognized USB drive. Don't worry if your USB or USB flash drive is not showing up on Mac.

Just pick up one of the listed methods and follow the guide steps to make your drive showing up and accessible again.

And don't forget to run EaseUS Data Recovery Wizard for Mac to scan and find all your USB data after fixing this issue.

Memory usage

If you're reading this article for tips on how to improve your Mac OS X experience, now's the time to pay attention. Aside from purchasing a new Mac, the most important thing you can do to make Mac OS X more bearable is to buy more RAM. Go ahead, don't be shy. 512MB sticks are going for as little as $50 if you look hard enough.

Frequent readers may recall that both the G3/400 and the dual G4/450 had only 256MB RAM at the time of the 10.0 review. After using 10.0.x for a few weeks on the G4, I got sick of hearing my disk grinding constantly and upgraded to 512MB. The silence that followed was truly golden. It was a bigger improvement than any of the 10.0.x upgrades, by far.

(Although the G3/400 primarily runs Mac OS 9, I upgraded it to 384MB because, well, RAM was too damn cheap not to, I guess.)

After a few weeks at 512MB, the G4 started to get a little grind-happy again. I shuffled some RAM between machines to boost the G4 again to its current total of 768MB, and noticed a nearly linear boost in 'smoothness' in daily use.

What's going on here? Where is all this memory going? Is Mac OS X a black hole for RAM? In a word, yes. But that's actually a good thing...sort of. I talked about Mac OS X's virtual memory system as it relates to the user experience and the infamous 'minimum required system' in the 10.0 article. I'd like to take a short break from the 'review' portion of this article and go into more detail about Mac OS X's memory system (as requested by numerous readers). Feel free to skip ahead to the summary if you're only interested in the RAM usage performance of 10.1 relative to 10.0.x.

(Note: A lot of the information presented below is heavily simplified in an effort to reach as broad an audience as possible. If you're interested in the gory details, picking up a good book on the topic is your best bet.)

Virtual Memory Basics

Mac OS X manages memory very differently than classic Mac OS. The first key to understanding memory usage in Mac OS X is to be understand how a modern virtual memory system works.

In a virtual memory management system, there is a distinction between real, physical memory and 'virtual' memory. An application's virtual memory size is the amount of memory the application thinks it has allocated, but only a (possibly very small) portion of that memory may actually be stored in the real, physical RAM chips sticking out of your computer's motherboard at any given time. The rest exists on disk in some form, usually in one or more 'swap files.'

The operating system decides what portion of which processes exist in physical memory at any given time. This decision process is complex, and varies from OS to OS, but it usually uses recent usage statistics in its decision making process. A process that has not accessed a particular piece of (real, physical) memory for a long time may find that memory written out to disk so that another more active process can use that piece of physical memory. When a process has a large portion of its memory removed from physical RAM and placed on the disk, it is said to be 'swapped out.'

If a process needs a previously swapped-out piece of memory again, it will be transferred from disk back into physical memory—possibly in a different location than its earlier home in physical memory. When a previously swapped-out application becomes active again and causes a large portion of its memory to move from disk back to physical memory, it is said to be 'swapped in.'

To simplify memory management, the operating system deals with memory in uniform units of a minimum size (usually 4K) called 'pages.' Swapping out a page is also called a 'pageout', and swapping in a page is called a 'pagein.' The policy used by the operating system to control memory management is often called the 'paging algorithm.'

Memory pages may store almost anything: code, data, even pieces of files. In fact, one of the useful features of virtual memory is that entire files may be 'memory mapped': a file on disk may be accessed as if it's a series of memory pages that have been swapped out to disk.

Further optimization is possible by allowing processes that need access to the same information (code, data, files) to share memory pages. Only when one of the processes sharing a particular memory page chooses to modify that page is a private copy created. This behavior is aptly named 'copy-on-write', and it allows many processes to efficiently share memory, with only the 'differences' allocated separately.

Not all memory may be swapped out. Some pages are 'wired down', meaning they may never leave physical memory during their lifetime. The memory pages that contain the operating system code that control the paging algorithm can never be swapped out, for instance (think about it). In fact, much of the operating system kernel is usually wired down.

Each active process needs some minimum portion of its memory pages to exist in physical memory in order to function efficiently. This portion is called the 'working set.' When the working set of all the active processes cannot fit in physical memory, the operating system must constantly shuttle pages to and from physical memory and the disk in a sort of game of musical chairs gone terribly wrong. A computer in this state is said to be 'thrashing.' The only cure is to either decrease the number active processes or buy more RAM.

The Buffer Cache

The second most important factor in Mac OS X's memory usage behavior is the buffer cache. The buffer cache is meant to speed up access to files on disk. Every time a piece of data is read from the disk, it may (optionally) be stored in memory. If that same piece of data is needed again in the near future, it may still be available in (physical) memory, saving a trip to the disk. Mac OS X implements a 'unified buffer cache', meaning that the buffer cache and the virtual memory system are combined. A page is a page is a page in Mac OS X.

Picking Up The Pieces Mac Os 11

The buffer cache affects RAM usage in ways that a Mac user may not expect. Heavy file i/o can use a lot of physical memory very quickly, potentially thinning out the physical memory presence of running applications. Poorly written applications may exacerbate this problem by using cached file i/o when it is not necessary, or even useful. An application that reads and parses a large file a single time during start-up should probably not use caching i/o, since it is not likely that the application will need those memory pages again some time in the near future before they're evicted from physical memory by another active process.

Picking Up The Pieces Mac Os X

The Window Server

The final major player in the Mac OS X memory ballet is, perhaps surprisingly, the window server. The window server orchestrates access to the screen, including both low-level drawing and higher-level concepts like the movement and layering of windows.

As discussed in earlier articles, the Quartz display layer (of which the window server is an important part) models the screen as a layered compositing engine much like the layers in a graphics application like Photoshop. Each pixel has a red, green, and blue components, plus a so-called 'alpha channel' which determines its transparency, from totally opaque to totally invisible. The appearance of each pixel on the screen is determined by the composite of all the applications that have a pixel in that position. The window server calculates the composite of those pixels based on the layering and visibility of the participating pixels.

This provides the infrastructure for many of the 'pretty' effects in Mac OS X: the transparent drop-shadows on the windows, the translucent menus and title bars, etc. Each individual application only needs to worry about its own pixels, without regard for anything in front of or behind it. The window server then composites those pixels and draws the result to the screen. This makes application development simpler, leaving the 'hard work' of creating those nice on-screen effects to the operating system rather than each application.

Things get tricky again something on the screen has to move or change color (or transparency). The window server must re-composite every pixel changed by an application before the change can become visible to the user. And the compositing calculation needs not only the value of the changed pixel, but also the values of all other pixels that contribute to that position.

Think about the calculations necessary to do something as simply as move a window in Mac OS X. Every pixel of that window must be re-composited with every pixel of every application in each location for each new position of the window. Imagine a 500x300 pixel window (about 24 rows of 80 column text) moved 100 pixels to the right, with 5 other application windows behind it. That's about 15 million compositing calculations, each with 30 operands (red, green, blue, and alpha values for each contributing pixel from each application), all for moving a small window a few inches.

But wait, there's more. When something changes on the screen (a window moves, appears, or disappears), pixels belonging to other applications are revealed. Those pixels must, of course, be composited before they can be displayed, and those compositing calculations need all the pixel values for each application that has a pixel in the newly revealed area. Adding the compositing calculations associated with the newly revealed screen area in the moving window example above (and accounting for the transparent drop-shadow on the window) brings the grand total to almost 17 million 20-30 operand calculations!

Of course, this is a worst-case scenario that would only happen in a very naive implementation. Many optimization are possible. Solid pixels can abbreviate the number and difficulty of the compositing calculations tremendously, especially if the front-most pixel is solid.

But there's no getting around the fact that the window server still needs access to all the pixels of all the windows on the screen at all times, since it never knows when one of them will be required in a compositing calculation. Furthermore, this access needs to be very fast, since no one wants to wait while the OS reads pixels from a slow medium like disk.

Mac OS X provides the window server with fast access to pixels by making all windows 'buffered.' All the pixels of a buffered window are stored in in memory. When one of those pixels is needed in a compositing calculation, the window server simply reads the memory location corresponding to that pixel. It does not have to 'ask' the application for the pixel. In fact, an application may be entirely frozen and unresponsive, but its window can still be moved around, hidden, and revealed without any participation from the application. When an application wants to change its window, the changes are all sent through the window server, which updates the window's buffer to reflect the changes.

This is a big change from classic Mac OS, where each application drew directly to the screen, and any newly revealed portion of a window had to be re-drawn by the application that owned that window. Window buffering and compositing had to be implemented explicitly by each application that wanted it, and it was totally independent of any other running applications.

From a development perspective, buffered windows make applications easier to code. Drawing only has to be done once, after which portions of the window may be hidden and revealed without triggering any custom redraw code in the application. From a user's perspective, window buffering allows newly revealed windows to 'just be there,' with no visible redraw. Buffering also provides smooth, flicker-free window movement. Mac OS X even goes so far as to synchronize screen drawing with the sweep of the electron beam on CRTs to avoid flicker and 'tearing.'

Quartz's buffering is generally a good thing. It improves the visual quality of on-screen elements and it makes application development easier. But what does all of this have to do with memory usage?

We've already seen the potentially tremendous number of calculations required to composite items on the screen. These calculations are all done by the CPU in Mac OS X, and are not off-loaded to a video card's GPU. But surprisingly, this is not as large a CPU hit as you might expect, thanks to both the common case of totally opaque pixels and the speed of today's CPUs (yes, even on Macs). A few million calculations every once in a while may cause a some instantaneous load on the CPU, but it is not really a factor in the long term. That said, it would be great to have the video card do these calculations rather than the CPU—something I'm sure Apple is working on. In pathological cases (e.g. the famous shaking transparent terminal window) the CPU load can briefly become significant.

But it's the memory usage that's the real killer. Classic Mac OS applications only need to retain the essential information about each window: its size, features, and contents. Mac OS X applications have to retain the same information, of course, but remember that the window server also has to retain a complete memory image of every pixel in the window! Repeat this for every single window on the screen, and it adds up very quickly.

Classic Mac OS requires only a few kilobytes to store the basic structures that define a simple, empty window. In Mac OS X, the total memory required for even a completely empty window is proportional to its size, regardless of the nature of its contents (if any).

In my daily work as a web programmer, this difference is very apparent. The nature of the work requires many windows to be open at once: text editors, web browsers, terminals, etc. In classic Mac OS, each text editor window, for example, would require only a small amount of memory for the window itself, plus whatever backing store the editor keeps for the (ASCII) text in each window. In Mac OS X, each simple text editor window becomes a giant 32-bit image (in addition to the other information, of course). Multiply this phenomenon across all the other applications, each with many windows of their own, and you quickly run into trouble.

Take a look at this window list from a typical work day on my G4. The total memory used by window buffers alone is an astounding 120MB! And remember, this is before even accounting for things like, say, the memory required by the actual applications and the core OS itself!

(The possibility of decreasing the window server's memory usage—and, more importantly, decreasing memory bandwidth usage—by compressing inactive window buffers is intriguing, but this feature is not officially supported in 10.1.)

The window server uses the same virtual memory system as every other part of OS X, of course. That means that the memory that makes up each window buffer is eligible to be paged out just like any other piece of memory. This is where the real performance hit comes in. Attempting to manipulate a window that has had some or all of its window buffer pages swapped out is a painful, stuttering, disk grinding experience as the virtual memory system rapidly tries to bring those pages back into physical memory from disk (evicting other resident pages while doing so, of course).

I encounter this phenomenon on a grand scale every time I return to work on Monday, after a weekend spent connected to the G4 via the command line running non-GUI applications from the terminal. On those Monday mornings, almost every window buffer is likely to have been swapped out during the weekend. The disk grinding session that ensues when all the windows are paged back in as I start to use them again is quite spectacular.

And remember, this is a system with 768MB of RAM. But the OS doesn't care. My command line work over the weekend required significant memory (compiling, running web servers, etc.), and the OS provided it. None of the GUI applications were active over the weekend, so their pages were swapped out to disk to make way for the memory needs of the command line activity. This is to be construed as a feature.

So, buffered windows: friend or foe? In the end, they are a friend. The OS X window server provides a higher level of abstraction to applications. With more abstraction comes more resource usage. But 'increased abstraction' is essentially the definition of progress in the computer industry (otherwise we'd all still be programming in machine language). But like much of the rest of OS X, pervasive window buffering is slightly ahead of current state of hardware. Long-term, this is also a good thing, in my opinion. It's easier to wait for hardware to catch up to your ambitious (but clean) software architecture than it is to try to revamp your operating system in response to advances in hardware (just ask Apple ;-)

Swap File Optimizations

Since it is possible to use up almost any amount of physical RAM in OS X (I fill 768MB very quickly), further performance gains are still possible by moving the swap file(s) to a separate disk. No matter how much RAM you have, you will almost certainly hit the swap file eventually. The disk heads on the drive containing the OS and applications will already be scurrying around as they read and write application and OS code and data files. Making the swap file another stop on their frantic journey just adds yet another voice to the cacophony of disk grinding. Swap file access is especially painful since is usually interleaved with other disk operations: read a piece of application code from disk into memory, write an old memory page out to the swap file, read a piece of a data file into the buffer cache, write an old memory page out to the swap file, read a piece of application code from disk into memory...etc. etc. (Can you hear the grinding? :-)

Putting the swap file on a disk mechanism of its own allows the heads on that disk drive to benefit from better locality of reference (i.e. they don't have to move around as much), and frees the application and OS drive to concentrate on its tasks. There is no Apple-sanctioned way to move the swap file to another drive, and certainly no GUI for it. But brave users can follow the directions available on the web. Just be sure to make a total backup first, because you can potentially hose your entire system if you're not careful.

I only have one disk at work, but at home I've moved my swap file from the 12GB 5,400 RPM drive that houses OS X and all its applications to my 45GB 7,200 RPM Mac OS 9 drive. The reduction in disk grinding has been substantial.

Picking Up The Pieces Mac Os Download

Simply moving the swap file to dedicated partition on the same disk is of much smaller benefit (if any). The disk heads still need to make many trips to and from the swap partition and the rest of the disk. And since Mac OS X uses individual swap files (rather than a dedicated swap file system), a separate swap partition is only likely to make a significant difference if the previous swap files were heavily fragmented on disk. (Note: I'm talking about 'external' fragmentation, where pieces of each swap file are spread all over the disk. The swap files themselves are always heavily 'internally' fragmented, meaning difference pieces of memory are spread sparsely within each swap file.)

Picking Up The Pieces Mac OS