Latest reading news

reading

Homewood Public Library Awarded 2020 Baker & Taylor Summer Reading Program Grant

By www.ala.org
Published On :: Fri, 14 Feb 2020 15:45:12 +0000

The Association for Library Service to Children (ALSC) has awarded the 2020 ALSC/Baker & Taylor Summer Reading Program Grant to Homewood Public Library in Homewood, Alabama.

Full Article

reading

KZPK (Wild Country 99)/St. Cloud, MN Launches YouTube Reading Series For Kids

By www.allaccess.com
Published On :: Mon, 04 May 2020 01:20:01 -0700

LEIGHTON BROADCASTING Country KZPK (WILD COUNTRY 99)/ST. CLOUD, MN has launched the “Books with BROOK” YOUTUBE series in conjunction with SCHOLASTIC. MD/afternoon personality … more

Full Article

reading

How to Add a “Reading Mode” to Your Posts

By feedproxy.google.com
Published On :: Wed, 25 Jul 2012 16:00:20 +0000

In this post, I will show you a simple way to add a distraction-free "Reading Mode" to your blog. The purpose of adding a feature like this is to enable a visitor to remove all the clutter of your site, and focus solely on the post itself. In an ideal world; there would never be a need for such a feature. In reality though, sites have numerous other goals to achieve, such as brand building, serving ads, promoting other content etc. In this way, you can compromise between the two. Do what you need when the user first arrives, but get out of the way when they decide what to read.

Full Article

reading

Concurrency & Multithreading in iOS

By feedproxy.google.com
Published On :: Tue, 25 Feb 2020 08:00:00 -0500

Concurrency is the notion of multiple things happening at the same time. This is generally achieved either via time-slicing, or truly in parallel if multiple CPU cores are available to the host operating system. We've all experienced a lack of concurrency, most likely in the form of an app freezing up when running a heavy task. UI freezes don't necessarily occur due to the absence of concurrency — they could just be symptoms of buggy software — but software that doesn't take advantage of all the computational power at its disposal is going to create these freezes whenever it needs to do something resource-intensive. If you've profiled an app hanging in this way, you'll probably see a report that looks like this:

Anything related to file I/O, data processing, or networking usually warrants a background task (unless you have a very compelling excuse to halt the entire program). There aren't many reasons that these tasks should block your user from interacting with the rest of your application. Consider how much better the user experience of your app could be if instead, the profiler reported something like this:

Analyzing an image, processing a document or a piece of audio, or writing a sizeable chunk of data to disk are examples of tasks that could benefit greatly from being delegated to background threads. Let's dig into how we can enforce such behavior into our iOS applications.

A Brief History

In the olden days, the maximum amount of work per CPU cycle that a computer could perform was determined by the clock speed. As processor designs became more compact, heat and physical constraints started becoming limiting factors for higher clock speeds. Consequentially, chip manufacturers started adding additional processor cores on each chip in order to increase total performance. By increasing the number of cores, a single chip could execute more CPU instructions per cycle without increasing its speed, size, or thermal output. There's just one problem...

How can we take advantage of these extra cores? Multithreading.

Multithreading is an implementation handled by the host operating system to allow the creation and usage of n amount of threads. Its main purpose is to provide simultaneous execution of two or more parts of a program to utilize all available CPU time. Multithreading is a powerful technique to have in a programmer's toolbelt, but it comes with its own set of responsibilities. A common misconception is that multithreading requires a multi-core processor, but this isn't the case — single-core CPUs are perfectly capable of working on many threads, but we'll take a look in a bit as to why threading is a problem in the first place. Before we dive in, let's look at the nuances of what concurrency and parallelism mean using a simple diagram:

In the first situation presented above, we observe that tasks can run concurrently, but not in parallel. This is similar to having multiple conversations in a chatroom, and interleaving (context-switching) between them, but never truly conversing with two people at the same time. This is what we call concurrency. It is the illusion of multiple things happening at the same time when in reality, they're switching very quickly. Concurrency is about dealing with lots of things at the same time. Contrast this with the parallelism model, in which both tasks run simultaneously. Both execution models exhibit multithreading, which is the involvement of multiple threads working towards one common goal. Multithreading is a generalized technique for introducing a combination of concurrency and parallelism into your program.

The Burden of Threads

A modern multitasking operating system like iOS has hundreds of programs (or processes) running at any given moment. However, most of these programs are either system daemons or background processes that have very low memory footprint, so what is really needed is a way for individual applications to make use of the extra cores available. An application (process) can have many threads (sub-processes) operating on shared memory. Our goal is to be able to control these threads and use them to our advantage.

Historically, introducing concurrency to an app has required the creation of one or more threads. Threads are low-level constructs that need to be managed manually. A quick skim through Apple's Threaded Programming Guide is all it takes to see how much complexity threaded code adds to a codebase. In addition to building an app, the developer has to:

Responsibly create new threads, adjusting that number dynamically as system conditions change
Manage them carefully, deallocating them from memory once they have finished executing
Leverage synchronization mechanisms like mutexes, locks, and semaphores to orchestrate resource access between threads, adding even more overhead to application code
Mitigate risks associated with coding an application that assumes most of the costs associated with creating and maintaining any threads it uses, and not the host OS

This is unfortunate, as it adds enormous levels of complexity and risk without any guarantees of improved performance.

Grand Central Dispatch

iOS takes an asynchronous approach to solving the concurrency problem of managing threads. Asynchronous functions are common in most programming environments, and are often used to initiate tasks that might take a long time, like reading a file from the disk, or downloading a file from the web. When invoked, an asynchronous function executes some work behind the scenes to start a background task, but returns immediately, regardless of how long the original task might takes to actually complete.

A core technology that iOS provides for starting tasks asynchronously is Grand Central Dispatch (or GCD for short). GCD abstracts away thread management code and moves it down to the system level, exposing a light API to define tasks and execute them on an appropriate dispatch queue. GCD takes care of all thread management and scheduling, providing a holistic approach to task management and execution, while also providing better efficiency than traditional threads.

Let's take a look at the main components of GCD:

What've we got here? Let's start from the left:

DispatchQueue.main: The main thread, or the UI thread, is backed by a single serial queue. All tasks are executed in succession, so it is guaranteed that the order of execution is preserved. It is crucial that you ensure all UI updates are designated to this queue, and that you never run any blocking tasks on it. We want to ensure that the app's run loop (called CFRunLoop) is never blocked in order to maintain the highest framerate. Subsequently, the main queue has the highest priority, and any tasks pushed onto this queue will get executed immediately.
DispatchQueue.global: A set of global concurrent queues, each of which manage their own pool of threads. Depending on the priority of your task, you can specify which specific queue to execute your task on, although you should resort to using default most of the time. Because tasks on these queues are executed concurrently, it doesn't guarantee preservation of the order in which tasks were queued.

Notice how we're not dealing with individual threads anymore? We're dealing with queues which manage a pool of threads internally, and you will shortly see why queues are a much more sustainable approach to multhreading.

Serial Queues: The Main Thread

As an exercise, let's look at a snippet of code below, which gets fired when the user presses a button in the app. The expensive compute function can be anything. Let's pretend it is post-processing an image stored on the device.

import UIKit

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        compute()
    }

    private func compute() -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

At first glance, this may look harmless, but if you run this inside of a real app, the UI will freeze completely until the loop is terminated, which will take... a while. We can prove it by profiling this task in Instruments. You can fire up the Time Profiler module of Instruments by going to Xcode > Open Developer Tool > Instruments in Xcode's menu options. Let's look at the Threads module of the profiler and see where the CPU usage is highest.

We can see that the Main Thread is clearly at 100% capacity for almost 5 seconds. That's a non-trivial amount of time to block the UI. Looking at the call tree below the chart, we can see that the Main Thread is at 99.9% capacity for 4.43 seconds! Given that a serial queue works in a FIFO manner, tasks will always complete in the order in which they were inserted. Clearly the compute() method is the culprit here. Can you imagine clicking a button just to have the UI freeze up on you for that long?

Background Threads

How can we make this better? DispatchQueue.global() to the rescue! This is where background threads come in. Referring to the GCD architecture diagram above, we can see that anything that is not the Main Thread is a background thread in iOS. They can run alongside the Main Thread, leaving it fully unoccupied and ready to handle other UI events like scrolling, responding to user events, animating etc. Let's make a small change to our button click handler above:

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        DispatchQueue.global(qos: .userInitiated).async { [unowned self] in
            self.compute()
        }
    }

    private func compute() -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

Unless specified, a snippet of code will usually default to execute on the Main Queue, so in order to force it to execute on a different thread, we'll wrap our compute call inside of an asynchronous closure that gets submitted to the DispatchQueue.global queue. Keep in mind that we aren't really managing threads here. We're submitting tasks (in the form of closures or blocks) to the desired queue with the assumption that it is guaranteed to execute at some point in time. The queue decides which thread to allocate the task to, and it does all the hard work of assessing system requirements and managing the actual threads. This is the magic of Grand Central Dispatch. As the old adage goes, you can't improve what you can't measure. So we measured our truly terrible button click handler, and now that we've improved it, we'll measure it once again to get some concrete data with regards to performance.

Looking at the profiler again, it's quite clear to us that this is a huge improvement. The task takes an identical amount of time, but this time, it's happening in the background without locking up the UI. Even though our app is doing the same amount of work, the perceived performance is much better because the user will be free to do other things while the app is processing.

You may have noticed that we accessed a global queue of .userInitiated priority. This is an attribute we can use to give our tasks a sense of urgency. If we run the same task on a global queue of and pass it a qos attribute of background , iOS will think it's a utility task, and thus allocate fewer resources to execute it. So, while we don't have control over when our tasks get executed, we do have control over their priority.

A Note on Main Thread vs. Main Queue

You might be wondering why the Profiler shows "Main Thread" and why we're referring to it as the "Main Queue". If you refer back to the GCD architecture we described above, the Main Queue is solely responsible for managing the Main Thread. The Dispatch Queues section in the Concurrency Programming Guide says that "the main dispatch queue is a globally available serial queue that executes tasks on the application’s main thread. Because it runs on your application’s main thread, the main queue is often used as a key synchronization point for an application."

The terms "execute on the Main Thread" and "execute on the Main Queue" can be used interchangeably.

Concurrent Queues

So far, our tasks have been executed exclusively in a serial manner. DispatchQueue.main is by default a serial queue, and DispatchQueue.global gives you four concurrent dispatch queues depending on the priority parameter you pass in.

Let's say we want to take five images, and have our app process them all in parallel on background threads. How would we go about doing that? We can spin up a custom concurrent queue with an identifier of our choosing, and allocate those tasks there. All that's required is the .concurrent attribute during the construction of the queue.

class ViewController: UIViewController {
    let queue = DispatchQueue(label: "com.app.concurrentQueue", attributes: .concurrent)
    let images: [UIImage] = [UIImage].init(repeating: UIImage(), count: 5)

    @IBAction func handleTap(_ sender: Any) {
        for img in images {
            queue.async { [unowned self] in
                self.compute(img)
            }
        }
    }

    private func compute(_ img: UIImage) -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

Running that through the profiler, we can see that the app is now spinning up 5 discrete threads to parallelize a for-loop.

Parallelization of N Tasks

So far, we've looked at pushing computationally expensive task(s) onto background threads without clogging up the UI thread. But what about executing parallel tasks with some restrictions? How can Spotify download multiple songs in parallel, while limiting the maximum number up to 3? We can go about this in a few ways, but this is a good time to explore another important construct in multithreaded programming: semaphores.

Semaphores are signaling mechanisms. They are commonly used to control access to a shared resource. Imagine a scenario where a thread can lock access to a certain section of the code while it executes it, and unlocks after it's done to let other threads execute the said section of the code. You would see this type of behavior in database writes and reads, for example. What if you want only one thread writing to a database and preventing any reads during that time? This is a common concern in thread-safety called Readers-writer lock. Semaphores can be used to control concurrency in our app by allowing us to lock n number of threads.

let kMaxConcurrent = 3 // Or 1 if you want strictly ordered downloads!
let semaphore = DispatchSemaphore(value: kMaxConcurrent)
let downloadQueue = DispatchQueue(label: "com.app.downloadQueue", attributes: .concurrent)

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        for i in 0..<15 {
            downloadQueue.async { [unowned self] in
                // Lock shared resource access
                semaphore.wait()

                // Expensive task
                self.download(i + 1)

                // Update the UI on the main thread, always!
                DispatchQueue.main.async {
                    tableView.reloadData()

                    // Release the lock
                    semaphore.signal()
                }
            }
        }
    }

    func download(_ songId: Int) -> Void {
        var counter = 0

        // Simulate semi-random download times.
        for _ in 0..<Int.random(in: 999999...10000000) {
            counter += songId
        }
    }
}

Notice how we've effectively restricted our download system to limit itself to k number of downloads. The moment one download finishes (or thread is done executing), it decrements the semaphore, allowing the managing queue to spawn another thread and start downloading another song. You can apply a similar pattern to database transactions when dealing with concurrent reads and writes.

Semaphores usually aren't necessary for code like the one in our example, but they become more powerful when you need to enforce synchronous behavior whille consuming an asynchronous API. The above could would work just as well with a custom NSOperationQueue with a maxConcurrentOperationCount, but it's a worthwhile tangent regardless.

Finer Control with OperationQueue

GCD is great when you want to dispatch one-off tasks or closures into a queue in a 'set-it-and-forget-it' fashion, and it provides a very lightweight way of doing so. But what if we want to create a repeatable, structured, long-running task that produces associated state or data? And what if we want to model this chain of operations such that they can be cancelled, suspended and tracked, while still working with a closure-friendly API? Imagine an operation like this:

This would be quite cumbersome to achieve with GCD. We want a more modular way of defining a group of tasks while maintaining readability and also exposing a greater amount of control. In this case, we can use Operation objects and queue them onto an OperationQueue, which is a high-level wrapper around DispatchQueue. Let's look at some of the benefits of using these abstractions and what they offer in comparison to the lower-level GCI API:

You may want to create dependencies between tasks, and while you could do this via GCD, you're better off defining them concretely as Operation objects, or units of work, and pushing them onto your own queue. This would allow for maximum reusability since you may use the same pattern elsewhere in an application.
The Operation and OperationQueue classes have a number of properties that can be observed, using KVO (Key Value Observing). This is another important benefit if you want to monitor the state of an operation or operation queue.
Operations can be paused, resumed, and cancelled. Once you dispatch a task using Grand Central Dispatch, you no longer have control or insight into the execution of that task. The Operation API is more flexible in that respect, giving the developer control over the operation's life cycle.
OperationQueue allows you to specify the maximum number of queued operations that can run simultaneously, giving you a finer degree of control over the concurrency aspects.

The usage of Operation and OperationQueue could fill an entire blog post, but let's look at a quick example of what modeling dependencies looks like. (GCD can also create dependencies, but you're better off dividing up large tasks into a series of composable sub-tasks.) In order to create a chain of operations that depend on one another, we could do something like this:

class ViewController: UIViewController {
    var queue = OperationQueue()
    var rawImage = UIImage? = nil
    let imageUrl = URL(string: "https://example.com/portrait.jpg")!
    @IBOutlet weak var imageView: UIImageView!

    let downloadOperation = BlockOperation {
        let image = Downloader.downloadImageWithURL(url: imageUrl)
        OperationQueue.main.async {
            self.rawImage = image
        }
    }

    let filterOperation = BlockOperation {
        let filteredImage = ImgProcessor.addGaussianBlur(self.rawImage)
        OperationQueue.main.async {
            self.imageView = filteredImage
        }
    }

    filterOperation.addDependency(downloadOperation)

    [downloadOperation, filterOperation].forEach {
        queue.addOperation($0)
     }
}

So why not opt for a higher level abstraction and avoid using GCD entirely? While GCD is ideal for inline asynchronous processing, Operation provides a more comprehensive, object-oriented model of computation for encapsulating all of the data around structured, repeatable tasks in an application. Developers should use the highest level of abstraction possible for any given problem, and for scheduling consistent, repeated work, that abstraction is Operation. Other times, it makes more sense to sprinkle in some GCD for one-off tasks or closures that we want to fire. We can mix both OperationQueue and GCD to get the best of both worlds.

The Cost of Concurrency

DispatchQueue and friends are meant to make it easier for the application developer to execute code concurrently. However, these technologies do not guarantee improvements to the efficiency or responsiveness in an application. It is up to you to use queues in a manner that is both effective and does not impose an undue burden on other resources. For example, it's totally viable to create 10,000 tasks and submit them to a queue, but doing so would allocate a nontrivial amount of memory and introduce a lot of overhead for the allocation and deallocation of operation blocks. This is the opposite of what you want! It's best to profile your app thoroughly to ensure that concurrency is enhancing your app's performance and not degrading it.

We've talked about how concurrency comes at a cost in terms of complexity and allocation of system resources, but introducing concurrency also brings a host of other risks like:

Deadlock: A situation where a thread locks a critical portion of the code and can halt the application's run loop entirely. In the context of GCD, you should be very careful when using the dispatchQueue.sync { } calls as you could easily get yourself in situations where two synchronous operations can get stuck waiting for each other.
Priority Inversion: A condition where a lower priority task blocks a high priority task from executing, which effectively inverts their priorities. GCD allows for different levels of priority on its background queues, so this is quite easily a possibility.
Producer-Consumer Problem: A race condition where one thread is creating a data resource while another thread is accessing it. This is a synchronization problem, and can be solved using locks, semaphores, serial queues, or a barrier dispatch if you're using concurrent queues in GCD.
...and many other sorts of locking and data-race conditions that are hard to debug! Thread safety is of the utmost concern when dealing with concurrency.

Parting Thoughts + Further Reading

If you've made it this far, I applaud you. Hopefully this article gives you a lay of the land when it comes to multithreading techniques on iOS, and how you can use some of them in your app. We didn't get to cover many of the lower-level constructs like locks, mutexes and how they help us achieve synchronization, nor did we get to dive into concrete examples of how concurrency can hurt your app. We'll save those for another day, but you can dig into some additional reading and videos if you're eager to dive deeper.

Full Article

Code

reading

Concurrency & Multithreading in iOS

By feedproxy.google.com
Published On :: Tue, 25 Feb 2020 08:00:00 -0500

A Brief History

How can we take advantage of these extra cores? Multithreading.

The Burden of Threads

Responsibly create new threads, adjusting that number dynamically as system conditions change
Manage them carefully, deallocating them from memory once they have finished executing
Leverage synchronization mechanisms like mutexes, locks, and semaphores to orchestrate resource access between threads, adding even more overhead to application code
Mitigate risks associated with coding an application that assumes most of the costs associated with creating and maintaining any threads it uses, and not the host OS

This is unfortunate, as it adds enormous levels of complexity and risk without any guarantees of improved performance.

Grand Central Dispatch

Let's take a look at the main components of GCD:

What've we got here? Let's start from the left:

DispatchQueue.main: The main thread, or the UI thread, is backed by a single serial queue. All tasks are executed in succession, so it is guaranteed that the order of execution is preserved. It is crucial that you ensure all UI updates are designated to this queue, and that you never run any blocking tasks on it. We want to ensure that the app's run loop (called CFRunLoop) is never blocked in order to maintain the highest framerate. Subsequently, the main queue has the highest priority, and any tasks pushed onto this queue will get executed immediately.
DispatchQueue.global: A set of global concurrent queues, each of which manage their own pool of threads. Depending on the priority of your task, you can specify which specific queue to execute your task on, although you should resort to using default most of the time. Because tasks on these queues are executed concurrently, it doesn't guarantee preservation of the order in which tasks were queued.

Serial Queues: The Main Thread

import UIKit

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        compute()
    }

    private func compute() -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

Background Threads

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        DispatchQueue.global(qos: .userInitiated).async { [unowned self] in
            self.compute()
        }
    }

    private func compute() -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

A Note on Main Thread vs. Main Queue

The terms "execute on the Main Thread" and "execute on the Main Queue" can be used interchangeably.

Concurrent Queues

class ViewController: UIViewController {
    let queue = DispatchQueue(label: "com.app.concurrentQueue", attributes: .concurrent)
    let images: [UIImage] = [UIImage].init(repeating: UIImage(), count: 5)

    @IBAction func handleTap(_ sender: Any) {
        for img in images {
            queue.async { [unowned self] in
                self.compute(img)
            }
        }
    }

    private func compute(_ img: UIImage) -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

Running that through the profiler, we can see that the app is now spinning up 5 discrete threads to parallelize a for-loop.

Parallelization of N Tasks

let kMaxConcurrent = 3 // Or 1 if you want strictly ordered downloads!
let semaphore = DispatchSemaphore(value: kMaxConcurrent)
let downloadQueue = DispatchQueue(label: "com.app.downloadQueue", attributes: .concurrent)

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        for i in 0..<15 {
            downloadQueue.async { [unowned self] in
                // Lock shared resource access
                semaphore.wait()

                // Expensive task
                self.download(i + 1)

                // Update the UI on the main thread, always!
                DispatchQueue.main.async {
                    tableView.reloadData()

                    // Release the lock
                    semaphore.signal()
                }
            }
        }
    }

    func download(_ songId: Int) -> Void {
        var counter = 0

        // Simulate semi-random download times.
        for _ in 0..<Int.random(in: 999999...10000000) {
            counter += songId
        }
    }
}

Finer Control with OperationQueue

You may want to create dependencies between tasks, and while you could do this via GCD, you're better off defining them concretely as Operation objects, or units of work, and pushing them onto your own queue. This would allow for maximum reusability since you may use the same pattern elsewhere in an application.
The Operation and OperationQueue classes have a number of properties that can be observed, using KVO (Key Value Observing). This is another important benefit if you want to monitor the state of an operation or operation queue.
Operations can be paused, resumed, and cancelled. Once you dispatch a task using Grand Central Dispatch, you no longer have control or insight into the execution of that task. The Operation API is more flexible in that respect, giving the developer control over the operation's life cycle.
OperationQueue allows you to specify the maximum number of queued operations that can run simultaneously, giving you a finer degree of control over the concurrency aspects.

class ViewController: UIViewController {
    var queue = OperationQueue()
    var rawImage = UIImage? = nil
    let imageUrl = URL(string: "https://example.com/portrait.jpg")!
    @IBOutlet weak var imageView: UIImageView!

    let downloadOperation = BlockOperation {
        let image = Downloader.downloadImageWithURL(url: imageUrl)
        OperationQueue.main.async {
            self.rawImage = image
        }
    }

    let filterOperation = BlockOperation {
        let filteredImage = ImgProcessor.addGaussianBlur(self.rawImage)
        OperationQueue.main.async {
            self.imageView = filteredImage
        }
    }

    filterOperation.addDependency(downloadOperation)

    [downloadOperation, filterOperation].forEach {
        queue.addOperation($0)
     }
}

The Cost of Concurrency

We've talked about how concurrency comes at a cost in terms of complexity and allocation of system resources, but introducing concurrency also brings a host of other risks like:

Deadlock: A situation where a thread locks a critical portion of the code and can halt the application's run loop entirely. In the context of GCD, you should be very careful when using the dispatchQueue.sync { } calls as you could easily get yourself in situations where two synchronous operations can get stuck waiting for each other.
Priority Inversion: A condition where a lower priority task blocks a high priority task from executing, which effectively inverts their priorities. GCD allows for different levels of priority on its background queues, so this is quite easily a possibility.
Producer-Consumer Problem: A race condition where one thread is creating a data resource while another thread is accessing it. This is a synchronization problem, and can be solved using locks, semaphores, serial queues, or a barrier dispatch if you're using concurrent queues in GCD.
...and many other sorts of locking and data-race conditions that are hard to debug! Thread safety is of the utmost concern when dealing with concurrency.

Parting Thoughts + Further Reading

Full Article

Code

reading

How to – Create a Pair of Reading Glasses Icon

By feedproxy.google.com
Published On :: Thu, 23 Apr 2020 14:00:05 +0000

In today’s tutorial, we’re going to take a quick look behind the process of creating a pair of reading glasses icon, and see how we can take some simple shapes and turn them into a finished usable product. So, assuming you already have the software running, let’s jump straight into it! Tutorial Details: Reading Glasses […]

The post How to – Create a Pair of Reading Glasses Icon appeared first on Vectips.

Full Article

Tips and Tricks
design
glasses
icon
vector

reading

Concurrency & Multithreading in iOS

By feedproxy.google.com
Published On :: Tue, 25 Feb 2020 08:00:00 -0500

A Brief History

How can we take advantage of these extra cores? Multithreading.

The Burden of Threads

Responsibly create new threads, adjusting that number dynamically as system conditions change
Manage them carefully, deallocating them from memory once they have finished executing
Leverage synchronization mechanisms like mutexes, locks, and semaphores to orchestrate resource access between threads, adding even more overhead to application code
Mitigate risks associated with coding an application that assumes most of the costs associated with creating and maintaining any threads it uses, and not the host OS

This is unfortunate, as it adds enormous levels of complexity and risk without any guarantees of improved performance.

Grand Central Dispatch

Let's take a look at the main components of GCD:

What've we got here? Let's start from the left:

DispatchQueue.main: The main thread, or the UI thread, is backed by a single serial queue. All tasks are executed in succession, so it is guaranteed that the order of execution is preserved. It is crucial that you ensure all UI updates are designated to this queue, and that you never run any blocking tasks on it. We want to ensure that the app's run loop (called CFRunLoop) is never blocked in order to maintain the highest framerate. Subsequently, the main queue has the highest priority, and any tasks pushed onto this queue will get executed immediately.
DispatchQueue.global: A set of global concurrent queues, each of which manage their own pool of threads. Depending on the priority of your task, you can specify which specific queue to execute your task on, although you should resort to using default most of the time. Because tasks on these queues are executed concurrently, it doesn't guarantee preservation of the order in which tasks were queued.

Serial Queues: The Main Thread

import UIKit

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        compute()
    }

    private func compute() -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

Background Threads

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        DispatchQueue.global(qos: .userInitiated).async { [unowned self] in
            self.compute()
        }
    }

    private func compute() -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

A Note on Main Thread vs. Main Queue

The terms "execute on the Main Thread" and "execute on the Main Queue" can be used interchangeably.

Concurrent Queues

class ViewController: UIViewController {
    let queue = DispatchQueue(label: "com.app.concurrentQueue", attributes: .concurrent)
    let images: [UIImage] = [UIImage].init(repeating: UIImage(), count: 5)

    @IBAction func handleTap(_ sender: Any) {
        for img in images {
            queue.async { [unowned self] in
                self.compute(img)
            }
        }
    }

    private func compute(_ img: UIImage) -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

Running that through the profiler, we can see that the app is now spinning up 5 discrete threads to parallelize a for-loop.

Parallelization of N Tasks

let kMaxConcurrent = 3 // Or 1 if you want strictly ordered downloads!
let semaphore = DispatchSemaphore(value: kMaxConcurrent)
let downloadQueue = DispatchQueue(label: "com.app.downloadQueue", attributes: .concurrent)

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        for i in 0..<15 {
            downloadQueue.async { [unowned self] in
                // Lock shared resource access
                semaphore.wait()

                // Expensive task
                self.download(i + 1)

                // Update the UI on the main thread, always!
                DispatchQueue.main.async {
                    tableView.reloadData()

                    // Release the lock
                    semaphore.signal()
                }
            }
        }
    }

    func download(_ songId: Int) -> Void {
        var counter = 0

        // Simulate semi-random download times.
        for _ in 0..<Int.random(in: 999999...10000000) {
            counter += songId
        }
    }
}

Finer Control with OperationQueue

You may want to create dependencies between tasks, and while you could do this via GCD, you're better off defining them concretely as Operation objects, or units of work, and pushing them onto your own queue. This would allow for maximum reusability since you may use the same pattern elsewhere in an application.
The Operation and OperationQueue classes have a number of properties that can be observed, using KVO (Key Value Observing). This is another important benefit if you want to monitor the state of an operation or operation queue.
Operations can be paused, resumed, and cancelled. Once you dispatch a task using Grand Central Dispatch, you no longer have control or insight into the execution of that task. The Operation API is more flexible in that respect, giving the developer control over the operation's life cycle.
OperationQueue allows you to specify the maximum number of queued operations that can run simultaneously, giving you a finer degree of control over the concurrency aspects.

class ViewController: UIViewController {
    var queue = OperationQueue()
    var rawImage = UIImage? = nil
    let imageUrl = URL(string: "https://example.com/portrait.jpg")!
    @IBOutlet weak var imageView: UIImageView!

    let downloadOperation = BlockOperation {
        let image = Downloader.downloadImageWithURL(url: imageUrl)
        OperationQueue.main.async {
            self.rawImage = image
        }
    }

    let filterOperation = BlockOperation {
        let filteredImage = ImgProcessor.addGaussianBlur(self.rawImage)
        OperationQueue.main.async {
            self.imageView = filteredImage
        }
    }

    filterOperation.addDependency(downloadOperation)

    [downloadOperation, filterOperation].forEach {
        queue.addOperation($0)
     }
}

The Cost of Concurrency

We've talked about how concurrency comes at a cost in terms of complexity and allocation of system resources, but introducing concurrency also brings a host of other risks like:

Deadlock: A situation where a thread locks a critical portion of the code and can halt the application's run loop entirely. In the context of GCD, you should be very careful when using the dispatchQueue.sync { } calls as you could easily get yourself in situations where two synchronous operations can get stuck waiting for each other.
Priority Inversion: A condition where a lower priority task blocks a high priority task from executing, which effectively inverts their priorities. GCD allows for different levels of priority on its background queues, so this is quite easily a possibility.
Producer-Consumer Problem: A race condition where one thread is creating a data resource while another thread is accessing it. This is a synchronization problem, and can be solved using locks, semaphores, serial queues, or a barrier dispatch if you're using concurrent queues in GCD.
...and many other sorts of locking and data-race conditions that are hard to debug! Thread safety is of the utmost concern when dealing with concurrency.

Parting Thoughts + Further Reading

Full Article

Code

reading

Understanding Climate Change Means Reading Beyond Headlines

By feedproxy.google.com
Published On :: Sat, 11 Feb 2017 21:18:19 +0000

By David Suzuki The David Suzuki Foundation Seeing terms like “post-truth” and “alternative facts” gain traction in the news convinces me that politicians, media workers and readers could benefit from a refresher course in how science helps us understand the … Continue reading →

Full Article

Climate & Climate Change
Points of View & Opinions
Climate Change
climate research
extreme weather events

reading

Concurrency & Multithreading in iOS

By feedproxy.google.com
Published On :: Tue, 25 Feb 2020 08:00:00 -0500

A Brief History

How can we take advantage of these extra cores? Multithreading.

The Burden of Threads

Responsibly create new threads, adjusting that number dynamically as system conditions change
Manage them carefully, deallocating them from memory once they have finished executing
Leverage synchronization mechanisms like mutexes, locks, and semaphores to orchestrate resource access between threads, adding even more overhead to application code
Mitigate risks associated with coding an application that assumes most of the costs associated with creating and maintaining any threads it uses, and not the host OS

This is unfortunate, as it adds enormous levels of complexity and risk without any guarantees of improved performance.

Grand Central Dispatch

Let's take a look at the main components of GCD:

What've we got here? Let's start from the left:

DispatchQueue.main: The main thread, or the UI thread, is backed by a single serial queue. All tasks are executed in succession, so it is guaranteed that the order of execution is preserved. It is crucial that you ensure all UI updates are designated to this queue, and that you never run any blocking tasks on it. We want to ensure that the app's run loop (called CFRunLoop) is never blocked in order to maintain the highest framerate. Subsequently, the main queue has the highest priority, and any tasks pushed onto this queue will get executed immediately.
DispatchQueue.global: A set of global concurrent queues, each of which manage their own pool of threads. Depending on the priority of your task, you can specify which specific queue to execute your task on, although you should resort to using default most of the time. Because tasks on these queues are executed concurrently, it doesn't guarantee preservation of the order in which tasks were queued.

Serial Queues: The Main Thread

import UIKit

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        compute()
    }

    private func compute() -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

Background Threads

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        DispatchQueue.global(qos: .userInitiated).async { [unowned self] in
            self.compute()
        }
    }

    private func compute() -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

A Note on Main Thread vs. Main Queue

The terms "execute on the Main Thread" and "execute on the Main Queue" can be used interchangeably.

Concurrent Queues

class ViewController: UIViewController {
    let queue = DispatchQueue(label: "com.app.concurrentQueue", attributes: .concurrent)
    let images: [UIImage] = [UIImage].init(repeating: UIImage(), count: 5)

    @IBAction func handleTap(_ sender: Any) {
        for img in images {
            queue.async { [unowned self] in
                self.compute(img)
            }
        }
    }

    private func compute(_ img: UIImage) -> Void {
        // Pretending to post-process a large image.
        var counter = 0
        for _ in 0..<9999999 {
            counter += 1
        }
    }
}

Running that through the profiler, we can see that the app is now spinning up 5 discrete threads to parallelize a for-loop.

Parallelization of N Tasks

let kMaxConcurrent = 3 // Or 1 if you want strictly ordered downloads!
let semaphore = DispatchSemaphore(value: kMaxConcurrent)
let downloadQueue = DispatchQueue(label: "com.app.downloadQueue", attributes: .concurrent)

class ViewController: UIViewController {
    @IBAction func handleTap(_ sender: Any) {
        for i in 0..<15 {
            downloadQueue.async { [unowned self] in
                // Lock shared resource access
                semaphore.wait()

                // Expensive task
                self.download(i + 1)

                // Update the UI on the main thread, always!
                DispatchQueue.main.async {
                    tableView.reloadData()

                    // Release the lock
                    semaphore.signal()
                }
            }
        }
    }

    func download(_ songId: Int) -> Void {
        var counter = 0

        // Simulate semi-random download times.
        for _ in 0..<Int.random(in: 999999...10000000) {
            counter += songId
        }
    }
}

Finer Control with OperationQueue

You may want to create dependencies between tasks, and while you could do this via GCD, you're better off defining them concretely as Operation objects, or units of work, and pushing them onto your own queue. This would allow for maximum reusability since you may use the same pattern elsewhere in an application.
The Operation and OperationQueue classes have a number of properties that can be observed, using KVO (Key Value Observing). This is another important benefit if you want to monitor the state of an operation or operation queue.
Operations can be paused, resumed, and cancelled. Once you dispatch a task using Grand Central Dispatch, you no longer have control or insight into the execution of that task. The Operation API is more flexible in that respect, giving the developer control over the operation's life cycle.
OperationQueue allows you to specify the maximum number of queued operations that can run simultaneously, giving you a finer degree of control over the concurrency aspects.

class ViewController: UIViewController {
    var queue = OperationQueue()
    var rawImage = UIImage? = nil
    let imageUrl = URL(string: "https://example.com/portrait.jpg")!
    @IBOutlet weak var imageView: UIImageView!

    let downloadOperation = BlockOperation {
        let image = Downloader.downloadImageWithURL(url: imageUrl)
        OperationQueue.main.async {
            self.rawImage = image
        }
    }

    let filterOperation = BlockOperation {
        let filteredImage = ImgProcessor.addGaussianBlur(self.rawImage)
        OperationQueue.main.async {
            self.imageView = filteredImage
        }
    }

    filterOperation.addDependency(downloadOperation)

    [downloadOperation, filterOperation].forEach {
        queue.addOperation($0)
     }
}

The Cost of Concurrency

We've talked about how concurrency comes at a cost in terms of complexity and allocation of system resources, but introducing concurrency also brings a host of other risks like:

Deadlock: A situation where a thread locks a critical portion of the code and can halt the application's run loop entirely. In the context of GCD, you should be very careful when using the dispatchQueue.sync { } calls as you could easily get yourself in situations where two synchronous operations can get stuck waiting for each other.
Priority Inversion: A condition where a lower priority task blocks a high priority task from executing, which effectively inverts their priorities. GCD allows for different levels of priority on its background queues, so this is quite easily a possibility.
Producer-Consumer Problem: A race condition where one thread is creating a data resource while another thread is accessing it. This is a synchronization problem, and can be solved using locks, semaphores, serial queues, or a barrier dispatch if you're using concurrent queues in GCD.
...and many other sorts of locking and data-race conditions that are hard to debug! Thread safety is of the utmost concern when dealing with concurrency.

Parting Thoughts + Further Reading

Full Article

Code

reading

Unsupervised Domain Adaptation on Reading Comprehension. (arXiv:1911.06137v4 [cs.CL] UPDATED)

By arxiv.org
Published On ::

Reading comprehension (RC) has been studied in a variety of datasets with the boosted performance brought by deep neural networks. However, the generalization capability of these models across different domains remains unclear. To alleviate this issue, we are going to investigate unsupervised domain adaptation on RC, wherein a model is trained on labeled source domain and to be applied to the target domain with only unlabeled samples. We first show that even with the powerful BERT contextual representation, the performance is still unsatisfactory when the model trained on one dataset is directly applied to another target dataset. To solve this, we provide a novel conditional adversarial self-training method (CASe). Specifically, our approach leverages a BERT model fine-tuned on the source dataset along with the confidence filtering to generate reliable pseudo-labeled samples in the target domain for self-training. On the other hand, it further reduces domain distribution discrepancy through conditional adversarial learning across domains. Extensive experiments show our approach achieves comparable accuracy to supervised models on multiple large-scale benchmark datasets.

Full Article

reading

Deep Learning for Image-based Automatic Dial Meter Reading: Dataset and Baselines. (arXiv:2005.03106v1 [cs.CV])

By arxiv.org
Published On ::

Smart meters enable remote and automatic electricity, water and gas consumption reading and are being widely deployed in developed countries. Nonetheless, there is still a huge number of non-smart meters in operation. Image-based Automatic Meter Reading (AMR) focuses on dealing with this type of meter readings. We estimate that the Energy Company of Paran'a (Copel), in Brazil, performs more than 850,000 readings of dial meters per month. Those meters are the focus of this work. Our main contributions are: (i) a public real-world dial meter dataset (shared upon request) called UFPR-ADMR; (ii) a deep learning-based recognition baseline on the proposed dataset; and (iii) a detailed error analysis of the main issues present in AMR for dial meters. To the best of our knowledge, this is the first work to introduce deep learning approaches to multi-dial meter reading, and perform experiments on unconstrained images. We achieved a 100.0% F1-score on the dial detection stage with both Faster R-CNN and YOLO, while the recognition rates reached 93.6% for dials and 75.25% for meters using Faster R-CNN (ResNext-101).

Full Article

reading

Programmable clock spreading

By www.freepatentsonline.com
Published On :: Tue, 12 May 2015 08:00:00 EDT

An integrated circuit having a programmable clock spreader configured to generate a plurality of controllably skewed clock signals, each applied to a corresponding region within the integrated circuit with circuitry configured to be triggered off the applied clock signal. The programmable clock spreader is designed to enable customization of the current-demand characteristics exhibited by the integrated circuit, e.g., based on the circuit's spectral impedance profile, to cause transient voltage droops in the power-supply network of the integrated circuit to be sufficiently small to ensure proper and reliable operation of the integrated circuit.

Full Article

reading

Cutting insert for threading

By www.freepatentsonline.com
Published On :: Tue, 03 Jun 2014 08:00:00 EDT

A threading cutting insert achieves high shape accuracy of a screw to be processed, and saves on manufacturing cost. Therefore in the threading cutting insert, a plurality of tooth-shaped cutting edges are formed in a cross ridge line portion between a rake face and flanks formed in a cutting side face, wherein the plurality of mountain-shaped cutting edges provides at least one finishing cutting edge for transferring a shape of a screw, and at least one roughing cutting edge formed in a tooth shape smaller than that of the finishing cutting edge. A flank of the finishing cutting edge includes a first flank, and a second flank having a clearance angle larger than that of the first flank, wherein the finishing cutting edge, the first flank, and the second flank are sequentially provided in that order from the rake surface in a direction of a lower surface of the insert.

Full Article

reading

Tool for repairing cross-threading and other damage in threaded blind holes

By www.freepatentsonline.com
Published On :: Tue, 02 Sep 2014 08:00:00 EDT

A slotted inverse tap, compressible for insertion past damaged entry threads in blind holes. (FIG. 1 thru FIG. 5) The tool can be made to smaller sizes than that of prior art. An elongate slot (23) proceeds through a first threaded end (21), then well into a reduced diameter cylindrical body (25). After insertion to the hole bottom, a tabbed shim (28) is inserted to the slot from its side, then pressed down until stopped. The shim (28) enforces mating engagement with undamaged internal threads. A second end of hex and/or squared or other configuration facilitates use of a tap wrench or other tool for rotational extraction. Damaged threads are reformed/re-cut upon rotational withdrawal.

Full Article

reading

Document reading apparatus and document reading method

By www.freepatentsonline.com
Published On :: Tue, 10 Feb 2015 08:00:00 EST

Provided is a document reading apparatus capable of suppressing a shock that may occur when a trailing edge of a tabbed sheet passes through a roller pair. In an image reading section, when a document to be read is the tabbed sheet, a timing to start separation of the roller pair in response to detection of a trailing edge of the document is delayed by a time period corresponding to a tab length with respect to the timing to start separation when a document other than the tabbed sheet is conveyed. Thus, it is possible to prevent the shock when the trailing edge of the tabbed sheet passes through the roller pair, and to thereby suppress image reading failure due to the shock.

Full Article

reading

Optical recording and reading method, optical recording and reading apparatus, optical recording medium, and method for producing an optical recording medium

By www.freepatentsonline.com
Published On :: Tue, 14 Apr 2015 08:00:00 EDT

An optical recording medium includes a recording and reading layer that is previously staked or formed afterword and has no concavo-convex pattern for tracking control, and a servo layer in which a concavo-convex pattern or a groove for tracking control is formed. Information can be recorded in the recording and reading layer while tracking is performed using the servo layer.

Full Article

reading

Corn cob conveying and cleaning system using induction and air flow from a harvester for separating and spreading light crop residue

By www.freepatentsonline.com
Published On :: Tue, 12 Aug 2014 08:00:00 EDT

A cob conveying and cleaning system for use with a corn harvester, incorporating air induction in cooperation with an air flow from the harvester, for cleaning and separating lighter crop residue to be returned to the field from a mixed flow of the residue and cobs, such that the cleaned cobs can be collected, and the lighter residue optionally spread on the field. The air flow and induction are combined to cooperatively lift or draw the lighter residue from the mixed flow, and to optionally spread the removed lighter residue over a field. The induction apparatus can be located on the harvester, and used as a residue spreader when cobs are not collected.

Full Article

reading

Regulator of residue flow for spreading devices on agricultural combines

By www.freepatentsonline.com
Published On :: Tue, 04 Nov 2014 08:00:00 EST

An agricultural combine having an adjustable spreader assembly is provided that includes a spreader with one or a pair of regulators. The spreader includes a discharge opening about its lateral side. The regulator is pivotably connected to the lateral side of the spreader such that the regulator is in fluid communication with the discharge opening. The regulator can be configured to move from a retracted position to an extended position or to vary the direction of discharge of crop residue. The spreader can be a vertical spreader, a horizontal spreader, or a spread board.

Full Article

reading

Spreading arrangement and combine harvester with spreading arrangement

By www.freepatentsonline.com
Published On :: Tue, 27 Jan 2015 08:00:00 EST

Example embodiments relate to a combine harvester including a straw chopper having an inlet for unchopped straw, an outlet for chopped straw in an essentially horizontal direction, and a spreader fan, connected downstream of the outlet of the straw chopper and having an essentially horizontal plane of rotation, for spreading the chopped straw over a ground surface. The combine harvester further includes a guide member, which is arranged to deflect at least a part of the stream of chopped straw material to an axial intake of the spreader fan such that a part of chopped straw material meets the blades of the spreader fan in the direction of transport of the chopped straw material through the spreader fan at an acute angle (α) relative to the plane of rotation of the spreader fan.

Full Article

reading

Reading data stored in recording medium

By www.freepatentsonline.com
Published On :: Tue, 19 May 2015 08:00:00 EDT

A device for reading data recorded on a recording medium having multiple tracks, the device including: a receiver that receives designations of a number of data elements to be read; and a determination unit that determines an order of reading the data elements so that, no matter on which track of the tracks each of the data elements is recorded, the data elements are read in an order of recorded locations of the data elements in a direction along the tracks on which the data elements are recorded.

Full Article

reading

Method and system for reading closely-spaced data tracks

By www.freepatentsonline.com
Published On :: Tue, 19 May 2015 08:00:00 EDT

A method for reading a track of data may include positioning a read head at an initial position relative to the track of data and obtaining initial track signals, filtering the initial track signals, positioning the read head at an initial subsequent position relative to the track of data and obtaining initial subsequent track signals, and filtering the initial subsequent track signals. In an initial equalization, the filtered initial track signals and the filtered initial subsequent track signals are equalized to obtain equalized track signals. The read head is positioned at a further subsequent position relative to the track of data and further subsequent track signals are obtained The further subsequent track signals are filtered. In a subsequent equalization, previously obtained equalized track signals and the filtered further subsequent track signals are equalized. A storage device operating according to the method may have an equalizer in hardware or firmware.

Full Article

reading

Input device, image reading device, and image forming apparatus to authenticate the user based on a result received by input section

By www.freepatentsonline.com
Published On :: Tue, 26 May 2015 08:00:00 EDT

An input device includes a display section, an input section, and an authentication section. The display section has a display area and displays a plurality of symbols in respective first regions of the display area. The input section receives an input indicating which of the plurality of symbols displayed on the display section is selected by a user by specifying a position in the display area. The authentication section authenticates the user based a result received by the input section. The input section receives an input indicating which of the plurality of symbols is selected, by receiving an input indicating which of a plurality of second regions allocated to each first region is selected. The authentication section authenticates the user based on the first region corresponding to the selected symbol from among the plurality of first regions and the second region selected from among the plurality of second regions.

Full Article

reading

Scanner capable of detecting the orientation of arranged document and image reading apparatus including the same

By www.freepatentsonline.com
Published On :: Tue, 06 Aug 2013 08:00:00 EDT

Disclosed are a scanner and an image reading apparatus including the same. The scanner can include a transparent plate, a scanning unit configured to scan a document on the transparent plate, a first sensor and a second sensor. The first sensor is positioned in a first document zone that is associated with an area in which a first document type is to be positioned based on a first alignment reference point provided on the transparent plate. The second sensor is positioned in a second document zone that is associated with an area in which a second document type of a different size is positioned based on a second alignment reference point provided on the transparent plate. The first document zone and the second document zone are non-overlapping zones. The document type and/or orientation can be determined based on the detection signals from the first and second sensors.

Full Article

reading

Image reading apparatus

By www.freepatentsonline.com
Published On :: Tue, 14 Oct 2014 08:00:00 EDT

An image reading apparatus includes a reading unit, a feeding unit, a carriage holding the reading unit, a motor, a motor-side transmission gear, a feeding unit-side transmission gear, a carriage-side transmission gear, a switching gear which switches between a meshing state of meshing with the feeding unit-side transmission gear at a feeding unit-side position and a meshing state of meshing with the carriage-side transmission gear at a carriage-side position, a restraint member which applies a restraint force for restraining the switching of the switching gear, and a motor control unit which when switching the switching gear between the carriage-side position and the feeding unit-side position, executes a large torque control of controlling the motor to generate a switching torque which is larger than a moving reading torque to be generated by the motor at a time of document reading when executing a moving reading.

Full Article

reading

Image reading apparatus

By www.freepatentsonline.com
Published On :: Tue, 03 Mar 2015 08:00:00 EST

An image reading apparatus includes: a reading unit; a feeding unit; a carriage; a motor-side transmission gear for transmitting power from a motor; a carriage-side transmission gear for transmitting the power to the carriage; a feeding unit-side transmission gear for transmitting the power to the feeding unit; a switching gear switched between a meshing state with the carriage-side transmission gear at a carriage-side position and a meshing state with the feeding unit-side transmission gear at a feeding unit-side position; and a control device for performing: a first switching process for meshing the switching gear with the feeding unit-side transmission gear; a second switching process for meshing the switching gear with the carriage-side transmission gear; and an initialization process of the reading unit.

Full Article

reading

Frequency shift compensation, such as for use in a wireless utility meter reading environment

By www.freepatentsonline.com
Published On :: Tue, 12 Mar 2013 08:00:00 EDT

Methods and apparatus for computing the carrier frequency of a transmitter using frequency modulated digital data to compensate for frequency shifting of the transmitter and the receiver local oscillators and for bandwidth adjustment of the receiver's filter. In particular, methods and apparatus are disclosed for binary systems transmitting “1” and “0” data using decoded or undecoded received signals.

Full Article

reading

Detection device capable of accurately reading dots on dice

By www.freepatentsonline.com
Published On :: Tue, 07 Apr 2015 08:00:00 EDT

A detection device is used in a gaming machine that detects numbers of dots on a plurality of dice having wireless tags. The detection device reads the wireless tags which are embedded on each face of the dice by a reader having an antenna. The antenna of the reader includes a first antenna portion disposed substantially in a central portion of a field that supports the dice, and formed in a substantially circular shape, and a plurality of second antenna portions disposed so as to superimpose a detection area of the first antenna portion, and having a detection area larger than the first antenna portion. The first antenna portion and the plurality of the second antenna portions are disposed so as to have a portion of detection areas mutually superimposed on a playing board.

Full Article

reading

Laser scanning code symbol reading system

By www.freepatentsonline.com
Published On :: Tue, 26 May 2015 08:00:00 EDT

A laser scanning symbol reading system includes an analog scan data signal processor for producing digital data signals, wherein during each scanning cycle, a light collection and photo-detection module generates an analog scan data signal corresponding to a laser scanned symbol, a multi-channel parallel scan data signal processor/digitizer processes the analog scan data signal along multiple cascaded multi-stage signal processing channels, to generate digital data signals corresponding thereto, while a synchronized digital gain control module automatically processes the digital data signals in response to start of scan (SOS) signals generated by a SOS detector. Each signal processing channel supports different stages of amplification and filtering using a different set of band-pass filtering and gain parameters in each channel, to produce multiple digital first derivative data signals, and/or multiple digital scan data intensity data signals, having different signal amplitudes and dynamic range characteristics for use in decode processing.

Full Article

reading

Pre-paid usage system for encoded information reading terminals

By www.freepatentsonline.com
Published On :: Tue, 26 May 2015 08:00:00 EDT

A fleet management system for managing a fleet of encoded information reading (EIR) terminals can comprise one or more computers, a fleet management software module, and a payment processing software module in communication with the fleet management software module. The fleet management software module can be configured, responsive to receiving a customer initiated request, to generate an unlocking message upon processing a payment by the payment processing software module. The unlocking message can be provided by a bar code to be read by an EIR terminal, or by a bit stream to be transferred to an EIR terminal via network. Each EIR terminal can be configured to perform not more than a pre-defined number of EIR operations responsive to receiving the unlocking message.

Full Article

reading

Portable RFID reading terminal with visual indication of scan trace

By www.freepatentsonline.com
Published On :: Tue, 26 May 2015 08:00:00 EDT

A portable radio-frequency identifier (RFID) reading terminal can comprise a microprocessor, a memory, an RFID reading device, and a display. The portable RFID reading terminal can be configured to display a scan trace provided by a line comprising a plurality of time varying points. Each point can be defined by a projection of a radio frequency (RF) signal coverage shape of the RFID reading device onto a chosen plane at a given moment in time.

Full Article

reading

Apparatus for and method of optimizing target reading performance of imaging reader in both handheld and hands-free modes of operation

By www.freepatentsonline.com
Published On :: Tue, 14 Jul 2015 08:00:00 EDT

An imaging reader reads targets by image capture in both handheld and hands-free modes of operation. Upon detection of the mode of operation, a controller sets the resolution and frame rate of a solid-state imaging sensor to different values in each mode to optimize target reading performance in each mode.

Full Article

reading

Stationary standby sand spreading unit for roadways

By www.freepatentsonline.com
Published On :: Tue, 06 Aug 1996 08:00:00 EDT

A standby sanding unit for emergency sanding of icy roadways has a plurality of sand hoppers that are connected to a tank holding air under pressure. The hoppers have hopper type bottoms that have nozzles attached to the bottoms so that when air under pressure is provided to the upper portions of the tank, sand will be discharged out through the nozzles. The air pressure tank has valves that control the flow of air under pressure to the hoppers, when needed.

Full Article

reading

Spreading device for confined application of grain type materials

By www.freepatentsonline.com
Published On :: Tue, 09 Dec 2003 08:00:00 EST

A spreading device for confined application of grain type materials along a well-defined path on a road from a conveyor of a storing tank mounted on a moving vehicle includes a chute member mounted thereon that receives the materials from the conveyor and substantially drops them generally vertically under gravity on the road along the path in proximity and in front of a roller. The latter stops the materials relative to the road and confines, or packs, them on the road. The spreading device is adapted to be mounted on either side of the vehicle, in line with its wheels.

Full Article

reading

Metering device for sand spreading devices, especially for rail vehicles

By www.freepatentsonline.com
Published On :: Tue, 06 Sep 2005 08:00:00 EDT

Metering or dosing device for sand spreading apparatuses with a metering piston for sealing off and releasing the throughflow opening for the material to be spread, in which the metering piston and the opposite housing wall of the passage hole have profiles overlapping each other so that a labyrinth-like outflow of the spread material results.

Full Article

reading

Metering device for sand spreading devices, especially for rail vehicles

By www.freepatentsonline.com
Published On :: Tue, 16 Jun 2009 08:00:00 EDT

Full Article

reading

Sand spreading system

By www.freepatentsonline.com
Published On :: Tue, 06 Aug 2013 08:00:00 EDT

A system for spreading spreadings in front of the wheels of vehicles, in particular, rail vehicles, including at least one container for the spreadings, at least one device arranged below each spreadings container for metering the spreadings with an outlet opening for dispensing the metered spreadings and at least two devices for conveying the metered spreadings over at least two conveyor lines. The conveyor devices provided for the metering device are made up of a pneumatically operated multiple injector arranged beneath the outlet opening, with at least two separate cavities for the dispensing of the metered spreadings, with one compressed air connector per cavity, and a connector for the conveyor line in each cavity opposite the compressed air connection.

Full Article

reading

Coning and threading machine for high-pressure tubing

By www.freepatentsonline.com
Published On :: Tue, 28 Apr 2015 08:00:00 EDT

A machine permits an end of a thick-walled, high-pressure tubing to be chucked in a collet one time, coned, faced and threaded, using a coning head and threading head which are mounted on a carriage which can be translated laterally between three positions and the coning and threading heads parallel to the longitudinal axis of the workpiece to complete the coning and threading operations.

Full Article

reading

Radio communication device and response signal spreading method

By www.freepatentsonline.com
Published On :: Tue, 07 Jul 2015 08:00:00 EDT

A radio communication device capable of randomizing both inter-cell interference and intra-cell interference. In this device, a spreading section (214) primarily spreads a response signal in a ZAC sequence set by a control unit (209). A spreading section (217) secondarily spreads the primarily spread response signal in a block-wise spreading code sequence set by the control unit (209). The control unit (209) controls the cyclic shift amount of the ZAC sequence used for the primary spreading in the spreading section (214) and the block-wise spreading code sequence used for the secondary spreading in the spreading section (217) according to a set hopping pattern. The hopping pattern set by the control unit (209) is made up of two hierarchies. An LB-based hopping pattern different for each cell is defined in the first hierarchy in order to randomize the inter-cell interference. A hopping pattern different for each mobile station is defined in the second hierarchy in order to randomize the intra-cell interference.

Full Article

reading

Annotative information applying apparatus, annotative information applying method, recording medium, and electronic proofreading system

By www.freepatentsonline.com
Published On :: Tue, 26 May 2015 08:00:00 EDT

A proof information processing apparatus adds a plurality of types of annotative information to a proof image by use of a plurality of input modes for inputting respective different types of annotative information. A proof information processing method is carried out by using the proof information processing apparatus. A recording medium stores a program for performing the functions of the proof information processing apparatus. An electronic proofreading system includes the proof information processing apparatus and a remote server. At least one of input modes including a text input mode, a stylus input mode, a color information input mode, and a speech input mode is selected depending on characteristics of an image in a region of interest which is indicated.

Full Article

reading

Image capture based on scanning resolution setting compared to determined scanning resolution relative to target distance in barcode reading

By www.freepatentsonline.com
Published On :: Tue, 06 Oct 2015 08:00:00 EDT

An arrangement for, and a method of, electro-optically reading a target by image capture, employ an aiming assembly for projecting an aiming light pattern on the target that is located within a range of working distances relative to a housing, an imaging assembly for capturing an image of the target and of the aiming light pattern over a field of view, and a controller for determining a distance of the target relative to the housing based on a position of the aiming light pattern in the captured image, for determining a scanning resolution based on the determined distance, for comparing the determined scanning resolution with a scanning resolution setting, and for processing the captured image based on the comparison.

Full Article

reading

Reversible folio for tablet computer with reversible connection for keyboard and reading configuration

By www.freepatentsonline.com
Published On :: Tue, 19 May 2015 08:00:00 EDT

A reversible folio for a tablet computer has a tablet shell with a cavity removably receiving the tablet computer. A keyboard is pivotally and removably coupled to the tablet shell. A channel is pivotally coupled to an edge of the keyboard. An interior of the channel removably receives the proximal edge of the tablet shell, and has a profile mating with a profile of the tablet shell. The channel and proximal edge have first and second symmetrical magnet arrays, respectively. The proximal edge of the tablet shell physically mates with the channel of the keyboard, and the second magnet array of the tablet shell magnetically mates with the first magnet array of the channel, in both a first orientation and an opposite second orientation.

Full Article

reading

Needle threading and swaging system

By www.freepatentsonline.com
Published On :: Tue, 08 Aug 1995 08:00:00 EDT

An automated machine for attaching a suture to a surgical needle comprises a first apparatus located at a first predetermined location for sorting a plurality of randomly oriented needles and orienting each needle for automatic handling at a first predetermined location, each of the needles having a suture receiving opening formed therein. A second apparatus located at a second predetermined location is provided for automatically cutting an indefinite length of suture material to a definite length suture strand and for automatically inserting an end of the definite length suture strand into the suture receiving opening formed in the needle. Also provided is a third apparatus for swaging the needle to close the suture receiving opening about the suture to secure said suture thereto and form therefrom a needle and suture assembly. An indexing device automatically receives each individual needle in a predetermined orientation at the first predetermined location and conveys the needle for sequential processing from the first to the second locations to form the needle-suture assembly.

Full Article

reading

Gas carrying threading device of sewing machine

By www.freepatentsonline.com
Published On :: Tue, 06 Jan 2015 08:00:00 EST

Pressurized gas for carrying looper thread by gas is generated by gas supply pump operated by changing over a sewing-machine motor, which drives stitch forming device, looper threading is performed through loopers by one-touch operation. Gas carrying threading device of sewing machine, comprising: looper thread introduction mechanism inserts looper thread guided to loopers; hollow looper thread guide extends from looper thread introduction mechanism to looper thread inlets and has looper thread guide outlets; gas supply pump for performing looper threading by carrying looper thread by gas from looper thread introduction area through hollow looper thread guide to looper thread loop-taker point outlets; clutch for transmitting power from sewing machine motor M to drive shaft which drives stitch forming device including loopers at time of stitch formation or to gas supply pump at time of looper threading.

Full Article

reading

Threading device for sewing machine lower looper

By www.freepatentsonline.com
Published On :: Tue, 27 Jan 2015 08:00:00 EST

A threading device for a sewing machine lower looper is disclosed that can thread a lower looper safely and reliably by reliably preventing a main shaft from rotating when an operation of threading the lower looper is carried out.

Full Article

reading

Reading stand

By www.freepatentsonline.com
Published On :: Tue, 07 Oct 2014 08:00:00 EDT

The invention provides a reading stand. The reading stand may comprising a base portion including at least one base portion sidewall, the base portion sidewall being supported by the base portion; and a platform portion forming a support surface to support the document, the platform portion including at least one page holder to retain the document. The reading stand may further include a side support clip extending from the platform portion such that the base portion sidewall is receivable between the platform portion and the side support clip in an assembled position, the side support clip having a protuberance disposed thereon, the protuberance engageable with the base portion sidewall. The assembled position affords side reading.

Full Article

reading

APPARATUSES AND METHODS OF READING MEMORY CELLS

By www.freepatentsonline.com
Published On :: Thu, 29 Jun 2017 08:00:00 EDT

A method is provided for a reading memory even if there is a threshold voltage in an overlapped threshold voltage (VTH) region between a first state distribution and a second state distribution. The method includes ramping a bias on a memory cell a first time to determine a first threshold voltage (VTH1) of the memory cell and determining whether the VTH1 is within the overlapped VTH region. Upon determination that the memory cell is within the overlapped VTH region, the method further includes applying a write pulse to the memory cell; ramping a bias on the memory cell a second time to determine a second threshold voltage (VTH2); and determining the state of the memory cell prior to receiving the write pulse based on a comparison between the VTH1 and the VTH2.

Full Article

reading

Method and device for inspecting a threading of a tubular connection used in the oil industry

By www.freepatentsonline.com
Published On :: Tue, 19 May 2015 08:00:00 EDT

A device and method for inspecting a width of thread roots of a tubular component for exploration or working of hydrocarbon wells, the device including two arms each including a first and a second end, the first ends being connected together by a deformable portion allowing an angular displacement between the second ends, the second ends each carrying a contact element and a mechanism determining the angular displacement.

Full Article

reading

Apparatus and methods for spreading fiber bundles for the continuous production of prepreg

By www.freepatentsonline.com
Published On :: Tue, 23 Jul 2013 08:00:00 EDT

Apparatus for producing spread fiber bundles by strategic use of tension control throughout the device and use of higher differential speeds between driven rollers and line speed of the running fiber bundle are provided herein, along with methods for producing spread fibers, prepregs, and articles of manufacture therefrom.

Full Article

reading

Threading a saddle latigo strap to secure a saddle

By www.freepatentsonline.com
Published On :: Tue, 17 Jun 2014 08:00:00 EDT

A saddle latigo strap is threaded to secure a saddle. A body portion of a saddle latigo is looped through a permanent saddle rigging. A first end of the saddle latigo having a tapered portion is inserted through a second end. Notches of the body portion are engaged with holes of the first end to secure the saddle.

Full Article

reading

DATA READOUT DEVICE FOR READING OUT DATA FROM A DATA CARRIER

By www.freepatentsonline.com
Published On :: Thu, 18 May 2017 08:00:00 EDT

A data readout device (114) for reading out data from at least one data carrier (112) having data modules (116) located at least two different depths within the at least one data carrier (112) is disclosed. The data readout device (114) comprises: —at least one illumination source (122) for directing at least one light beam (124) onto the data carrier (112); -at least one detector (130) adapted for detecting at least one modified light beam modified by at least one of the data modules (116), the detector (130) having at least one optical sensor (132), wherein the optical sensor (132)has at least one sensor region (134), wherein the optical sensor (132)is designed to generate at least one sensor signal in a manner dependent on an illumination of the sensor region (134)by the modified light beam, wherein the sensor signal, given the same total power of the illumination,is dependent on a beam cross-section of the modified light beam in the sensor region (134); and -at least one evaluation device (136) adapted for evaluating the at least one sensor signal and for deriving data stored in the at least one data carrier (112) from the sensor signal. Further, a data storage system (110), a method for reading out data from at least one data carrier (112) and a use of an optical sensor (132) for reading out data are disclosed.

Full Article