nc

Mysterious Sharks Dance Away Bethel's COVID-19 Blues

By feeds.drudge.com
Published On :: Fri, 08 May 2020 22:31:46 -0400

A couple of mysterious sharks have caught the fancy of the town. Maybe it's the cabin fever finally setting in, or perhaps this is what happens when you go too long without washing your mask, but Bethelites are going wild for two people in inflatable shark suits who pop up randomly around town.


Full Article

nc

Independence and the Art of Timeless Work with Zoë Keating

By feedproxy.google.com
Published On :: Thu, 29 Aug 2019 05:03:23 +0000

A cellist since the age of eight, Zoë Keating pursued electronic music and contemporary composition as part of her Liberal Arts studies at Sarah Lawrence College in New York. I came across her music almost 10 years ago and love it so much I reached out to see if she would be interested on being on the show. Not only did she respond, she left us reeling from her incredible live performance and chat on art + entrepreneurship. Now she’s back on tour with her latest album Snowmelt. In this episode, we go deep into personal growth, dealing with incredible loss, balancing parenthood and career, and landscape for independent artists. Enjoy! FOLLOW ZOË: instagram | twitter | website Listen to the Podcast Subscribe   Watch the Episode  This podcast is brought to you by CreativeLive. CreativeLive is the world’s largest hub for online creative education in photo/video, art/design, music/audio, craft/maker, money/life and the ability to make a living in any of those disciplines. They are high quality, highly curated classes taught by the world’s top experts — Pulitzer, Oscar, Grammy Award winners, New York Times best selling authors and the best entrepreneurs of our times.

The post Independence and the Art of Timeless Work with Zoë Keating appeared first on Chase Jarvis Photography.


Full Article

nc

Harmony > Balance with Jason Calacanis

By feedproxy.google.com
Published On :: Wed, 06 Nov 2019 14:27:08 +0000

Today we’re going back to San Francisco with myself and Jason Calacanis on stage during my tour stop for my book Creative Calling. Jason is an investor and long time host of the This Week in Startups podcast. And, of course, Jason wastes no time in our conversation. He goes right to the heart of the matter by getting into failure, venture capitol, knowing when to quit, and when to push through. Enjoy! FOLLOW JASON: facebook | twitter | website Listen to the Podcast Subscribe   This podcast is brought to you by CreativeLive. CreativeLive is the world’s largest hub for online creative education in photo/video, art/design, music/audio, craft/maker, money/life and the ability to make a living in any of those disciplines. They are high quality, highly curated classes taught by the world’s top experts — Pulitzer, Oscar, Grammy Award winners, New York Times best selling authors and the best entrepreneurs of our times.

The post Harmony > Balance with Jason Calacanis appeared first on Chase Jarvis Photography.


Full Article

nc

Self Reliance + Personal Uprising with John Jantsch

By feedproxy.google.com
Published On :: Wed, 13 Nov 2019 14:01:38 +0000

John Jantsch is a veteran marketer. He’s written several bestselling books including Duct Tape Marketing and The Referral Engine. He’s out with a new book called the Self-Reliant Entrepreneur: 366 Daily Meditations to Feed Your Soul and Grow Your Business  As you might know, I’m a bit of a fan of daily habits, so of course John gives us a little preview into some of the daily explorations of thoughts and writings from notable American authors. Of course, that’s not all…  we also get into: We go deep into following your own path and listening to your intuition. What we can learn from rabble rousers of our history and those who embraced counter culture to follow their own beliefs. The role that self-awareness has in pursuing our dreams. and much more. Enjoy! FOLLOW JOHN: facebook | twitter | website Listen to the Podcast Subscribe   This podcast is brought to you by CreativeLive. CreativeLive is the world’s largest hub for online creative education in photo/video, art/design, music/audio, craft/maker, money/life and the ability to make a living in any of those disciplines. They are high quality, highly curated classes taught by the world’s top experts — Pulitzer, Oscar, Grammy Award winners, New […]

The post Self Reliance + Personal Uprising with John Jantsch appeared first on Chase Jarvis Photography.


Full Article

nc

Resilience and Going Untouchable with Neil Pasricha

By feedproxy.google.com
Published On :: Wed, 27 Nov 2019 14:15:36 +0000

Neil Pasricha is a bestselling author and podcaster whose work focuses on topics core to all of our lives: gratitude, happiness, failure, resilience, and trust. He’s the author of six books including The Book of Awesome, The Happiness Equation, Awesome Is Everywhere, and his latest book: You Are Awesome.  In this episode: We are too thin skinned. No matter how great our achievements, we’re crushed by the simplest things. Neil shares some practical advice to navigate through pain and build resiliency Always do something you’re learning… Or as I like to say, how to give yourself permission to suck There’s a reason why they call something a “practice”. We get into how to let go and allow yourself to be human. and much more Enjoy! FOLLOW NEIL: twitter | website Listen to the Podcast Subscribe   This podcast is brought to you by CreativeLive. CreativeLive is the world’s largest hub for online creative education in photo/video, art/design, music/audio, craft/maker, money/life and the ability to make a living in any of those disciplines. They are high quality, highly curated classes taught by the world’s top experts — Pulitzer, Oscar, Grammy Award winners, New York Times best selling authors and the best entrepreneurs […]

The post Resilience and Going Untouchable with Neil Pasricha appeared first on Chase Jarvis Photography.


Full Article

nc

There Is Only One You with Clemency Burton-Hill

By feedproxy.google.com
Published On :: Wed, 01 Jan 2020 15:17:19 +0000

There are 7106 languages on earth and yet there are a few universal languages that transcends the language barrier. In this episode we explore one of the first universal languages of human history: music. My guest today is Clemency Burton-Hill. From underground DJ to the Creative Director at New York Public Radio, she is an author, a musician, and host of multiple podcasts including The Open Ears Project, Classical Fix, and Moments that Made Me. Her latest book, Year of Wonder helps readers explore and experience a new classical musical piece every day. In this episode: Classical music has a bad rap for being stuffy, boring, and largely inaccessible. Clemency expands on what’s available, and how it’s really the soundtrack of our lives. The universality of music and how we use music to explore, express, and share. Of course, Clemency drops so many names of musical artists to explore who are crushing it today. Enjoy! FOLLOW CLEMENCY: instagram | twitter | website Listen to the Podcast  Subscribe   This podcast is brought to you by CreativeLive. CreativeLive is the world’s largest hub for online creative education in photo/video, art/design, music/audio, craft/maker, money/life and the ability to make a living in […]

The post There Is Only One You with Clemency Burton-Hill appeared first on Chase Jarvis Photography.


Full Article

nc

Getting Comfortable with Being Uncomfortable

By feedproxy.google.com
Published On :: Wed, 25 Mar 2020 13:15:01 +0000

Being uncomfortable isn’t usually fun. In fact, we’re probably more likely to try to avoid uncomfortable situations than actually run toward them. Yet, it is a valuable skill. Not only in dealing with adversity but giving us confidence and trust in ourselves to recover quickly from failure, manage our fears, and explore the unknown. In today’s episode, we dive a big deeper into this topic and I share a few ways we can all practice getting comfortable with being uncomfortable. Enjoy! FOLLOW CHASE: instagram | twitter | website Listen to the Podcast Subscribe   This podcast is brought to you by CreativeLive. CreativeLive is the world’s largest hub for online creative education in photo/video, art/design, music/audio, craft/maker, money/life and the ability to make a living in any of those disciplines. They are high quality, highly curated classes taught by the world’s top experts — Pulitzer, Oscar, Grammy Award winners, New York Times best selling authors and the best entrepreneurs of our times.

The post Getting Comfortable with Being Uncomfortable appeared first on Chase Jarvis Photography.


Full Article

nc

Finance Fireside Chat with Ramit Sethi

By feedproxy.google.com
Published On :: Mon, 20 Apr 2020 13:13:53 +0000

In this episode I’m chatting with my long time friend and financial guru, Ramit Sethi. Ramit has been on the show a number of times, and this time we’re connecting virtually from our living rooms during the quarantine. Of course we get into finances during these uncertain times, but more importantly: adaptation and resilience. Over the years, no one has single-handedly given me better insight about the business side of art than the New York Times bestselling author, Ramit Sethi. Take a listen and let us know what you think. Enjoy! This episode was part of CreativeLive TV, a brand-new, free, 24/7 variety show, live-streamed from the very casual living rooms, studios, and kitchen tables of our worldwide community of legendary creators. You can expect musical performances, Q&As, cooking, spoken word, drawing, and more – featuring many of our favorite personalities – all in a safe, virtual space full of joy, shared experiences, and connection via live, interactive chat. The schedule and upcoming broadcasts can be seen at http://creativelive.com/tv FOLLOW RAMIT: instagram | twitter | website Listen to the Podcast  Subscribe   Watch the Episode This podcast is brought to you by CreativeLive. CreativeLive is the world’s largest hub […]

The post Finance Fireside Chat with Ramit Sethi appeared first on Chase Jarvis Photography.


Full Article

nc

Resilience + Reinvention with Canlis Restaurateurs

By feedproxy.google.com
Published On :: Mon, 27 Apr 2020 21:00:34 +0000

In any uncertain time there, we can both feel anxious, upset, curious and we can also look for opportunities. Opportunities for reinvention, for connection, and community in ways we haven’t seen before. That’s the theme of today’s episode with some of my good friends Mark and Brian Canlis + James Beard Award Winning Chef Brady Williams in a conversation we recorded for CreativeLive TV. Mark and Brian run an iconic restaurant in Seattle named Canlis. It’s been a family business for over 70 years. Faced with these uncertain times, they share how they’ve reinvented their business 3 times over the last couple of months. No matter what industry you’re in, their story of overcoming obstacles, problem solving and heart is wisdom for all of us. Enjoy! FOLLOW CANLIS: instagram | website Listen to the Podcast Subscribe   Watch the Episode This podcast is brought to you by CreativeLive. CreativeLive is the world’s largest hub for online creative education in photo/video, art/design, music/audio, craft/maker, money/life and the ability to make a living in any of those disciplines. They are high quality, highly curated classes taught by the world’s top experts — Pulitzer, Oscar, Grammy Award winners, New York Times best selling authors […]

The post Resilience + Reinvention with Canlis Restaurateurs appeared first on Chase Jarvis Photography.


Full Article

nc

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

nc

Committed to the wrong branch? -, @{upstream}, and @{-1} to the rescue

By feedproxy.google.com
Published On :: Thu, 27 Feb 2020 00:00:00 -0500

I get into this situation sometimes. Maybe you do too. I merge feature work into a branch used to collect features, and then continue development but on that branch instead of back on the feature branch

git checkout feature
# ... bunch of feature commits ...
git push
git checkout qa-environment
git merge --no-ff --no-edit feature
git push
# deploy qa-environment to the QA remote environment
# ... more feature commits ...
# oh. I'm not committing in the feature branch like I should be

and have to move those commits to the feature branch they belong in and take them out of the throwaway accumulator branch

git checkout feature
git cherry-pick origin/qa-environment..qa-environment
git push
git checkout qa-environment
git reset --hard origin/qa-environment
git merge --no-ff --no-edit feature
git checkout feature
# ready for more feature commits

Maybe you prefer

git branch -D qa-environment
git checkout qa-environment

over

git checkout qa-environment
git reset --hard origin/qa-environment

Either way, that works. But it'd be nicer if we didn't have to type or even remember the branches' names and the remote's name. They are what is keeping this from being a context-independent string of commands you run any time this mistake happens. That's what we're going to solve here.

Shorthands for longevity

I like to use all possible natively supported shorthands. There are two broad motivations for that.

  1. Fingers have a limited number of movements in them. Save as many as possible left late in life.
  2. Current research suggests that multitasking has detrimental effects on memory. Development tends to be very heavy on multitasking. Maybe relieving some of the pressure on quick-access short term memory (like knowing all relevant branch names) add up to leave a healthier memory down the line.

First up for our scenario: the - shorthand, which refers to the previously checked out branch. There are a few places we can't use it, but it helps a lot:

Bash 
# USING -

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit -        # ????
git push
# hack hack hack
# whoops
git checkout -        # now on feature ???? 
git cherry-pick origin/qa-environment..qa-environment
git push
git checkout - # now on qa-environment ????
git reset --hard origin/qa-environment
git merge --no-ff --no-edit -        # ????
git checkout -                       # ????
# on feature and ready for more feature commits
Bash 
# ORIGINAL

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit feature
git push
# hack hack hack
# whoops
git checkout feature
git cherry-pick origin/qa-environment..qa-environment
git push
git checkout qa-environment
git reset --hard origin/qa-environment
git merge --no-ff --no-edit feature
git checkout feature
# ready for more feature commits

We cannot use - when cherry-picking a range

> git cherry-pick origin/-..-
fatal: bad revision 'origin/-..-'

> git cherry-pick origin/qa-environment..-
fatal: bad revision 'origin/qa-environment..-'

and even if we could we'd still have provide the remote's name (here, origin).

That shorthand doesn't apply in the later reset --hard command, and we cannot use it in the branch -D && checkout approach either. branch -D does not support the - shorthand and once the branch is deleted checkout can't reach it with -:

# assuming that branch-a has an upstream origin/branch-a
> git checkout branch-a
> git checkout branch-b
> git checkout -
> git branch -D -
error: branch '-' not found.
> git branch -D branch-a
> git checkout -
error: pathspec '-' did not match any file(s) known to git

So we have to remember the remote's name (we know it's origin because we are devoting memory space to knowing that this isn't one of those times it's something else), the remote tracking branch's name, the local branch's name, and we're typing those all out. No good! Let's figure out some shorthands.

@{-<n>} is hard to say but easy to fall in love with

We can do a little better by using @{-<n>} (you'll also sometimes see it referred to be the older @{-N}). It is a special construct for referring to the nth previously checked out ref.

> git checkout branch-a
> git checkout branch-b
> git rev-parse --abbrev-rev @{-1} # the name of the previously checked out branch
branch-a
> git checkout branch-c
> git rev-parse --abbrev-rev @{-2} # the name of branch checked out before the previously checked out one
branch-a

Back in our scenario, we're on qa-environment, we switch to feature, and then want to refer to qa-environment. That's @{-1}! So instead of

git cherry-pick origin/qa-environment..qa-environment

We can do

git cherry-pick origin/qa-environment..@{-1}

Here's where we are (🎉 marks wins from -, 💥 marks the win from @{-1})

Bash 
# USING - AND @{-1}

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit -                # ????
git push
# hack hack hack
# whoops
git checkout -                               # ????
git cherry-pick origin/qa-environment..@{-1} # ????
git push
git checkout -                               # ????
git reset --hard origin/qa-environment
git merge --no-ff --no-edit -                # ????
git checkout -                               # ????
# ready for more feature commits
Bash 
# ORIGINAL

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit feature
git push
# hack hack hack
# whoops
git checkout feature
git cherry-pick origin/qa-environment..qa-environment
git push
git checkout qa-environment
git reset --hard origin/qa-environment
git merge --no-ff --no-edit feature
git checkout feature
# ready for more feature commits

One down, two to go: we're still relying on memory for the remote's name and the remote branch's name and we're still typing both out in full. Can we replace those with generic shorthands?

@{-1} is the ref itself, not the ref's name, we can't do

> git cherry-pick origin/@{-1}..@{-1}
origin/@{-1}
fatal: ambiguous argument 'origin/@{-1}': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

because there is no branch origin/@{-1}. For the same reason, @{-1} does not give us a generalized shorthand for the scenario's later git reset --hard origin/qa-environment command.

But good news!

Do @{u} @{push}

@{upstream} or its shorthand @{u} is the remote branch a that would be pulled from if git pull were run. @{push} is the remote branch that would be pushed to if git push was run.

> git checkout branch-a
Switched to branch 'branch-a'
Your branch is ahead of 'origin/branch-a' by 3 commits.
  (use "git push" to publish your local commits)
> git reset --hard origin/branch-a
HEAD is now at <the SHA origin/branch-a is at>

we can

> git checkout branch-a
Switched to branch 'branch-a'
Your branch is ahead of 'origin/branch-a' by 3 commits.
  (use "git push" to publish your local commits)
> git reset --hard @{u}                                # <-- So Cool!
HEAD is now at <the SHA origin/branch-a is at>

Tacking either onto a branch name will give that branch's @{upstream} or @{push}. For example

git checkout branch-a@{u}

is the branch branch-a pulls from.

In the common workflow where a branch pulls from and pushes to the same branch, @{upstream} and @{push} will be the same, leaving @{u} as preferable for its terseness. @{push} shines in triangular workflows where you pull from one remote and push to another (see the external links below).

Going back to our scenario, it means short, portable commands with a minimum human memory footprint. (🎉 marks wins from -, 💥 marks the win from @{-1}, 😎 marks the wins from @{u}.)

Bash 
# USING - AND @{-1} AND @{u}

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit -    # ????
git push
# hack hack hack
# whoops
git checkout -                   # ????
git cherry-pick @{-1}@{u}..@{-1} # ????????
git push
git checkout -                   # ????
git reset --hard @{u}            # ????
git merge --no-ff --no-edit -    # ????
git checkout -                   # ????
# ready for more feature commits
Bash 
# ORIGINAL

git checkout feature
# hack hack hack
git push
git checkout qa-environment
git merge --no-ff --no-edit feature
git push
# hack hack hack
# whoops
git checkout feature
git cherry-pick origin/qa-environment..qa-environment
git push
git checkout qa-environment
git reset --hard origin/qa-environment
git merge --no-ff --no-edit feature
git checkout feature
# ready for more feature commits

Make the things you repeat the easiest to do

Because these commands are generalized, we can run some series of them once, maybe

git checkout - && git reset --hard @{u} && git checkout -

or

git checkout - && git cherry-pick @{-1}@{u}.. @{-1} && git checkout - && git reset --hard @{u} && git checkout -

and then those will be in the shell history just waiting to be retrieved and run again the next time, whether with CtrlR incremental search or history substring searching bound to the up arrow or however your interactive shell is configured. Or make it an alias, or even better an abbreviation if your interactive shell supports them. Save the body wear and tear, give memory a break, and level up in Git.

And keep going

The GitHub blog has a good primer on triangular workflows and how they can polish your process of contributing to external projects.

The FreeBSD Wiki has a more in-depth article on triangular workflow process (though it doesn't know about @{push} and @{upstream}).

The construct @{-<n>} and the suffixes @{push} and @{upstream} are all part of the gitrevisions spec. Direct links to each:


    Full Article

    • Code
    • Front-end Engineering
    • Back-end Engineering
    nc

    Join Our New Online Workshops On CSS, Accessibility, Performance, And UX

    By feedproxy.google.com
    Published On :: Thu, 30 Apr 2020 12:00:00 +0000

    It has been a month since we launched our first online workshop and, to be honest, we really didn’t know whether people would enjoy them — or if we would enjoy running them. It was an experiment, but one we are so glad we jumped into! I spoke about the experience of taking my workshop online on a recent episode of the Smashing podcast. As a speaker, I had expected it to feel very much like I was presenting into the empty air, with no immediate feedback and expressions to work from.


    Full Article

    nc

    Meet SmashingConf Live: Our New Interactive Online Conference

    By feedproxy.google.com
    Published On :: Tue, 05 May 2020 12:50:00 +0000

    In these strange times when everything is connected, it’s too easy to feel lonely and detached. Yes, everybody is just one message away, but there is always something in the way — deadlines to meet, Slack messages to reply, or urgent PRs to review. Connections need time and space to grow, just like learning, and conferences are a great way to find that time and that space. In fact, with SmashingConfs, we’ve always been trying to create such friendly and inclusive spaces.


    Full Article

    nc

    Aputure announces new LS-60D daylight and LX-60X bicolour LED lights

    By feedproxy.google.com
    Published On :: Thu, 07 May 2020 19:57:32 +0000

    Aputure’s been coming pretty thick and fast on the announcements lately, and now they’ve announced their new Light Storm 60D daylight and 60X bi-colour adjustable focusing LED lights. As the name suggests, these are 60 Watt LEDs, and everything is built inside the head, meaning there’s no external control unit to have to deal with. […]

    The post Aputure announces new LS-60D daylight and LX-60X bicolour LED lights appeared first on DIY Photography.


    Full Article

    nc

    Paper: Evidence for Area as the Primary Visual Cue in Pie Charts

    By eagereyes.org
    Published On :: Thu, 17 Oct 2019 15:52:12 +0000

    How we read pie charts is still an open question: is it angle? Is it area? Is it arc length? In a study I'm presenting as a short paper at the IEEE VIS conference in Vancouver next week, I tried to tease the visual cues apart – using modeling and 3D pie charts. The big […]


    Full Article

    nc

    eagereyesTV Episode 3: 3D Pie Charts For Science!

    By eagereyes.org
    Published On :: Mon, 21 Oct 2019 06:00:03 +0000

    How do we read pie charts? This seems like a straightforward question to answer, but it turns out that most of what you’ve probably heard is wrong. We don’t actually know whether we use angle, area, or arc length. In a short paper at the VIS conference this week I’m presenting a study I ran […]


    Full Article

    nc

    In Praise of the Diagonal Reference Line

    By eagereyes.org
    Published On :: Tue, 24 Mar 2020 05:51:19 +0000

    Annotations are what set visual communication and journalism apart from just visualization. They often consist of text, but some of the most useful annotations are graphical elements, and many of them are very simple. One type I have a particular fondness for is the diagonal reference line, which has been used to provide powerful context […]


    Full Article

    nc

    Double Chance Picks *** Sunday *** 17 September 2017

    By dataviz.tumblr.com
    Published On :: Sat, 16 Sep 2017 19:45:05 -0400

    We have a new preview on https://www.007soccerpicks.com/sunday-matches/double-chance-picks-sunday-17-september-2017/

    Double Chance Picks *** Sunday *** 17 September 2017

    DOUBLE CHANCE PICKS To return: ??? USD Odds: 2.80 Stake: 100 USD   Starting in   Teams   Our Prediction Odds Las Palmas - Ath Bilbao Soccer: Spain - LaLiga X2 1.45 Chievo - Atalanta Soccer: Italy - Serie…


    Full Article

    nc

    Double Chance Picks *** Monday *** 18 September 2017

    By dataviz.tumblr.com
    Published On :: Sun, 17 Sep 2017 19:01:41 -0400

    We have a new preview on https://www.007soccerpicks.com/monday-matches/double-chance-picks-monday-18-september-2017/

    Double Chance Picks *** Monday *** 18 September 2017

    DOUBLE CHANCE PICKS To return: ??? USD Odds: 2.03 Stake: 100 USD   Starting in   Teams   Our Prediction Odds Espanyol - Celta Vigo Soccer: Spain - LaLiga 1X 1.29 AFC Eskilstuna - Sundsvall Soccer: Sweden -…


    Full Article

    nc

    Double Chance Picks *** Tuesday *** 19 September 2017

    By dataviz.tumblr.com
    Published On :: Mon, 18 Sep 2017 16:05:25 -0400

    We have a new preview on https://www.007soccerpicks.com/tuesday-matches/double-chance-picks-tuesday-19-september-2017/

    Double Chance Picks *** Tuesday *** 19 September 2017

    DOUBLE CHANCE PICKS To return: ??? USD Odds: 1.95 Stake: 100 USD   Starting in   Teams   Our Prediction Odds Bournemouth - Brighton Soccer: England - Carabao Cup 1X 1.20 Wolfsburg - SV Werder Bremen Soccer: Germany…


    Full Article

    nc

    The entropy of holomorphic correspondences: exact computations and rational semigroups. (arXiv:2004.13691v1 [math.DS] CROSS LISTED)

    By arxiv.org
    Published On ::

    We study two notions of topological entropy of correspondences introduced by Friedland and Dinh-Sibony. Upper bounds are known for both. We identify a class of holomorphic correspondences whose entropy in the sense of Dinh-Sibony equals the known upper bound. This provides an exact computation of the entropy for rational semigroups. We also explore a connection between these two notions of entropy.


    Full Article

    nc

    Solutions for nonlinear Fokker-Planck equations with measures as initial data and McKean-Vlasov equations. (arXiv:2005.02311v2 [math.AP] UPDATED)

    By arxiv.org
    Published On ::

    One proves the existence and uniqueness of a generalized (mild) solution for the nonlinear Fokker--Planck equation (FPE) egin{align*} &u_t-Delta (eta(u))+{mathrm{ div}}(D(x)b(u)u)=0, quad tgeq0, xinmathbb{R}^d, d e2, \ &u(0,cdot)=u_0,mbox{in }mathbb{R}^d, end{align*} where $u_0in L^1(mathbb{R}^d)$, $etain C^2(mathbb{R})$ is a nondecreasing function, $bin C^1$, bounded, $bgeq 0$, $Din(L^2cap L^infty)(mathbb{R}^d;mathbb{R}^d)$ with ${ m div}, Din L^infty(mathbb{R}^d)$, and ${ m div},Dgeq0$, $eta$ strictly increasing, if $b$ is not constant. Moreover, $t o u(t,u_0)$ is a semigroup of contractions in $L^1(mathbb{R}^d)$, which leaves invariant the set of probability density functions in $mathbb{R}^d$. If ${ m div},Dgeq0$, $eta'(r)geq a|r|^{alpha-1}$, and $|eta(r)|leq C r^alpha$, $alphageq1,$ $alpha>frac{d-2}d$, $dgeq3$, then $|u(t)|_{L^infty}le Ct^{-frac d{d+(alpha-1)d}} |u_0|^{frac2{2+(m-1)d}},$ $t>0$, and the existence extends to initial data $u_0$ in the space $mathcal{M}_b$ of bounded measures in $mathbb{R}^d$. The solution map $mumapsto S(t)mu$, $tgeq0$, is a Lipschitz contractions on $mathcal{M}_b$ and weakly continuous in $tin[0,infty)$. As a consequence for arbitrary initial laws, we obtain weak solutions to a class of McKean-Vlasov SDEs with coefficients which have singular dependence on the time marginal laws.


    Full Article

    nc

    Entropy and Emergence of Topological Dynamical Systems. (arXiv:2005.01548v2 [math.DS] UPDATED)

    By arxiv.org
    Published On ::

    A topological dynamical system $(X,f)$ induces two natural systems, one is on the probability measure spaces and other one is on the hyperspace.

    We introduce a concept for these two spaces, which is called entropy order, and prove that it coincides with topological entropy of $(X,f)$. We also consider the entropy order of an invariant measure and a variational principle is established.


    Full Article

    nc

    Resonances as Viscosity Limits for Exponentially Decaying Potentials. (arXiv:2005.01257v2 [math.SP] UPDATED)

    By arxiv.org
    Published On ::

    We show that the complex absorbing potential (CAP) method for computing scattering resonances applies to the case of exponentially decaying potentials. That means that the eigenvalues of $-Delta + V - iepsilon x^2$, $|V(x)|leq e^{-2gamma |x|}$ converge, as $ epsilon o 0+ $, to the poles of the meromorphic continuation of $ ( -Delta + V -lambda^2 )^{-1} $ uniformly on compact subsets of $ extrm{Re},lambda>0$, $ extrm{Im},lambda>-gamma$, $arglambda > pi/8$.


    Full Article

    nc

    Equivalence of classical and quantum completeness for real principal type operators on the circle. (arXiv:2004.07547v3 [math.AP] UPDATED)

    By arxiv.org
    Published On ::

    In this article, we prove that the completeness of the Hamilton flow and essential self-dajointness are equivalent for real principal type operators on the circle. Moreover, we study spectral properties of these operators.


    Full Article

    nc

    The $kappa$-Newtonian and $kappa$-Carrollian algebras and their noncommutative spacetimes. (arXiv:2003.03921v2 [hep-th] UPDATED)

    By arxiv.org
    Published On ::

    We derive the non-relativistic $c oinfty$ and ultra-relativistic $c o 0$ limits of the $kappa$-deformed symmetries and corresponding spacetime in (3+1) dimensions, with and without a cosmological constant. We apply the theory of Lie bialgebra contractions to the Poisson version of the $kappa$-(A)dS quantum algebra, and quantize the resulting contracted Poisson-Hopf algebras, thus giving rise to the $kappa$-deformation of the Newtonian (Newton-Hooke and Galilei) and Carrollian (Para-Poincar'e, Para-Euclidean and Carroll) quantum symmetries, including their deformed quadratic Casimir operators. The corresponding $kappa$-Newtonian and $kappa$-Carrollian noncommutative spacetimes are also obtained as the non-relativistic and ultra-relativistic limits of the $kappa$-(A)dS noncommutative spacetime. These constructions allow us to analyze the non-trivial interplay between the quantum deformation parameter $kappa$, the curvature parameter $eta$ and the speed of light parameter $c$.


    Full Article

    nc

    Three-point Functions in $mathcal{N}=4$ SYM at Finite $N_c$ and Background Independence. (arXiv:2002.07216v2 [hep-th] UPDATED)

    By arxiv.org
    Published On ::

    We compute non-extremal three-point functions of scalar operators in $mathcal{N}=4$ super Yang-Mills at tree-level in $g_{YM}$ and at finite $N_c$, using the operator basis of the restricted Schur characters. We make use of the diagrammatic methods called quiver calculus to simplify the three-point functions. The results involve an invariant product of the generalized Racah-Wigner tensors ($6j$ symbols). Assuming that the invariant product is written by the Littlewood-Richardson coefficients, we show that the non-extremal three-point functions satisfy the large $N_c$ background independence; correspondence between the string excitations on $AdS_5 imes S^5$ and those in the LLM geometry.


    Full Article

    nc

    A stochastic approach to the synchronization of coupled oscillators. (arXiv:2002.04472v2 [nlin.AO] UPDATED)

    By arxiv.org
    Published On ::

    This paper deals with an optimal control problem associated to the Kuramoto model describing the dynamical behavior of a network of coupled oscillators. Our aim is to design a suitable control function allowing us to steer the system to a synchronized configuration in which all the oscillators are aligned on the same phase. This control is computed via the minimization of a given cost functional associated with the dynamics considered. For this minimization, we propose a novel approach based on the combination of a standard Gradient Descent (GD) methodology with the recently-developed Random Batch Method (RBM) for the efficient numerical approximation of collective dynamics. Our simulations show that the employment of RBM improves the performances of the GD algorithm, reducing the computational complexity of the minimization process and allowing for a more efficient control calculation.


    Full Article

    nc

    EMSx: A Numerical Benchmark for Energy Management Systems. (arXiv:2001.00450v2 [math.OC] UPDATED)

    By arxiv.org
    Published On ::

    Inserting renewable energy in the electric grid in a decentralized manneris a key challenge of the energy transition. However, at local scale, both production and demand display erratic behavior, which makes it delicate to match them. It is the goal of Energy Management Systems (EMS) to achieve such balance at least cost. We present EMSx, a numerical benchmark for testing control algorithms for the management of electric microgrids equipped with a photovoltaic unit and an energy storage system. EMSx is made of three key components: the EMSx dataset, provided by Schneider Electric, contains a diverse pool of realistic microgrids with a rich collection of historical observations and forecasts; the EMSx mathematical framework is an explicit description of the assessment of electric microgrid control techniques and algorithms; the EMSx software EMSx.jl is a package, implemented in the Julia language, which enables to easily implement a microgrid controller and to test it. All components of the benchmark are publicly available, so that other researchers willing to test controllers on EMSx may reproduce experiments easily. Eventually, we showcase the results of standard microgrid control methods, including Model Predictive Control, Open Loop Feedback Control and Stochastic Dynamic Programming.


    Full Article

    nc

    Linear Convergence of First- and Zeroth-Order Primal-Dual Algorithms for Distributed Nonconvex Optimization. (arXiv:1912.12110v2 [math.OC] UPDATED)

    By arxiv.org
    Published On ::

    This paper considers the distributed nonconvex optimization problem of minimizing a global cost function formed by a sum of local cost functions by using local information exchange. We first propose a distributed first-order primal-dual algorithm. We show that it converges sublinearly to the stationary point if each local cost function is smooth and linearly to the global optimum under an additional condition that the global cost function satisfies the Polyak-{L}ojasiewicz condition. This condition is weaker than strong convexity, which is a standard condition for proving the linear convergence of distributed optimization algorithms, and the global minimizer is not necessarily unique or finite. Motivated by the situations where the gradients are unavailable, we then propose a distributed zeroth-order algorithm, derived from the proposed distributed first-order algorithm by using a deterministic gradient estimator, and show that it has the same convergence properties as the proposed first-order algorithm under the same conditions. The theoretical results are illustrated by numerical simulations.


    Full Article

    nc

    Khintchine-type theorems for values of subhomogeneous functions at integer points. (arXiv:1910.02067v2 [math.NT] UPDATED)

    By arxiv.org
    Published On ::

    This work has been motivated by recent papers that quantify the density of values of generic quadratic forms and other polynomials at integer points, in particular ones that use Rogers' second moment estimates. In this paper we establish such results in a very general framework. Namely, given any subhomogeneous function (a notion to be defined) $f: mathbb{R}^n o mathbb{R}$, we derive a necessary and sufficient condition on the approximating function $psi$ for guaranteeing that a generic element $fcirc g$ in the $G$-orbit of $f$ is $psi$-approximable; that is, $|fcirc g(mathbf{v})| le psi(|mathbf{v}|)$ for infinitely many $mathbf{v} in mathbb{Z}^n$. We also deduce a sufficient condition in the case of uniform approximation. Here, $G$ can be any closed subgroup of $operatorname{ASL}_n(mathbb{R})$ satisfying certain axioms that allow for the use of Rogers-type estimates.


    Full Article

    nc

    Monochromatic Equilateral Triangles in the Unit Distance Graph. (arXiv:1909.09856v2 [math.CO] UPDATED)

    By arxiv.org
    Published On ::

    Let $chi_{Delta}(mathbb{R}^{n})$ denote the minimum number of colors needed to color $mathbb{R}^{n}$ so that there will not be a monochromatic equilateral triangle with side length $1$. Using the slice rank method, we reprove a result of Frankl and Rodl, and show that $chi_{Delta}left(mathbb{R}^{n} ight)$ grows exponentially with $n$. This technique substantially improves upon the best known quantitative lower bounds for $chi_{Delta}left(mathbb{R}^{n} ight)$, and we obtain [ chi_{Delta}left(mathbb{R}^{n} ight)>(1.01446+o(1))^{n}. ]


    Full Article

    nc

    On boundedness, gradient estimate, blow-up and convergence in a two-species and two-stimuli chemotaxis system with/without loop. (arXiv:1909.04587v4 [math.AP] UPDATED)

    By arxiv.org
    Published On ::

    In this work, we study dynamic properties of classical solutions to a homogenous Neumann initial-boundary value problem (IBVP) for a two-species and two-stimuli chemotaxis model with/without chemical signalling loop in a 2D bounded and smooth domain. We successfully detect the product of two species masses as a feature to determine boundedness, gradient estimates, blow-up and $W^{j,infty}(1leq jleq 3)$-exponential convergence of classical solutions for the corresponding IBVP. More specifically, we first show generally a smallness on the product of both species masses, thus allowing one species mass to be suitably large, is sufficient to guarantee global boundedness, higher order gradient estimates and $W^{j,infty}$-convergence with rates of convergence to constant equilibria; and then, in a special case, we detect a straight line of masses on which blow-up occurs for large product of masses. Our findings provide new understandings about the underlying model, and thus, improve and extend greatly the existing knowledge relevant to this model.


    Full Article

    nc

    Multitype branching process with nonhomogeneous Poisson and generalized Polya immigration. (arXiv:1909.03684v2 [math.PR] UPDATED)

    By arxiv.org
    Published On ::

    In a multitype branching process, it is assumed that immigrants arrive according to a nonhomogeneous Poisson or a generalized Polya process (both processes are formulated as a nonhomogeneous birth process with an appropriate choice of transition intensities). We show that the renormalized numbers of objects of the various types alive at time $t$ for supercritical, critical, and subcritical cases jointly converge in distribution under those two different arrival processes. Furthermore, some transient moment analysis when there are only two types of particles is provided. AMS 2000 subject classifications: Primary 60J80, 60J85; secondary 60K10, 60K25, 90B15.


    Full Article

    nc

    Poisson Dixmier-Moeglin equivalence from a topological point of view. (arXiv:1908.06542v2 [math.RA] UPDATED)

    By arxiv.org
    Published On ::

    In this paper, we provide some topological criteria for the Poisson Dixmier-Moeglin equivalence for $A$ in terms of the poset $({ m P. spec A}, subseteq)$ and the symplectic leaf or core stratification on its maximal spectrum. In particular, we prove that the Zariski topology of the Poisson prime spectrum and of each symplectic leaf or core can detect the Poisson Dixmier-Moeglin equivalence for any complex affine Poisson algebra. Moreover, we generalize the weaker version of the Poisson Dixmier-Moeglin equivalence for a complex affine Poisson algebra proved in [J. Bell, S. Launois, O.L. S'anchez, and B. Moosa, Poisson algebras via model theory and differential algebraic geometry, J. Eur. Math. Soc. (JEMS), 19(2017), no. 7, 2019-2049] to the general context of a commutative differential algebra.


    Full Article

    nc

    Study of fractional Poincar'e inequalities on unbounded domains. (arXiv:1904.07170v2 [math.AP] UPDATED)

    By arxiv.org
    Published On ::

    The central aim of this paper is to study (regional) fractional Poincar'e type inequalities on unbounded domains satisfying the finite ball condition. Both existence and non existence type results are established depending on various conditions on domains and on the range of $s in (0,1)$. The best constant in both regional fractional and fractional Poincar'e inequality is characterized for strip like domains $(omega imes mathbb{R}^{n-1})$, and the results obtained in this direction are analogous to those of the local case. This settles one of the natural questions raised by K. Yeressian in [ extit{Asymptotic behavior of elliptic nonlocal equations set in cylinders, Asymptot. Anal. 89, (2014), no 1-2}].


    Full Article

    nc

    Diophantine Equations Involving the Euler Totient Function. (arXiv:1902.01638v4 [math.NT] UPDATED)

    By arxiv.org
    Published On ::

    We deal with various Diophantine equations involving the Euler totient function and various sequences of numbers, including factorials, powers, and Fibonacci sequences.


    Full Article

    nc

    Bernoulli decomposition and arithmetical independence between sequences. (arXiv:1811.11545v2 [math.NT] UPDATED)

    By arxiv.org
    Published On ::

    In this paper we study the following set[A={p(n)+2^nd mod 1: ngeq 1}subset [0.1],] where $p$ is a polynomial with at least one irrational coefficient on non constant terms, $d$ is any real number and for $ain [0,infty)$, $a mod 1$ is the fractional part of $a$. By a Bernoulli decomposition method, we show that the closure of $A$ must have full Hausdorff dimension.


    Full Article

    nc

    Optimal construction of Koopman eigenfunctions for prediction and control. (arXiv:1810.08733v3 [math.OC] UPDATED)

    By arxiv.org
    Published On ::

    This work presents a novel data-driven framework for constructing eigenfunctions of the Koopman operator geared toward prediction and control. The method leverages the richness of the spectrum of the Koopman operator away from attractors to construct a rich set of eigenfunctions such that the state (or any other observable quantity of interest) is in the span of these eigenfunctions and hence predictable in a linear fashion. The eigenfunction construction is optimization-based with no dictionary selection required. Once a predictor for the uncontrolled part of the system is obtained in this way, the incorporation of control is done through a multi-step prediction error minimization, carried out by a simple linear least-squares regression. The predictor so obtained is in the form of a linear controlled dynamical system and can be readily applied within the Koopman model predictive control framework of [12] to control nonlinear dynamical systems using linear model predictive control tools. The method is entirely data-driven and based purely on convex optimization, with no reliance on neural networks or other non-convex machine learning tools. The novel eigenfunction construction method is also analyzed theoretically, proving rigorously that the family of eigenfunctions obtained is rich enough to span the space of all continuous functions. In addition, the method is extended to construct generalized eigenfunctions that also give rise Koopman invariant subspaces and hence can be used for linear prediction. Detailed numerical examples with code available online demonstrate the approach, both for prediction and feedback control.


    Full Article

    nc

    Twisted Sequences of Extensions. (arXiv:1808.07936v3 [math.RT] UPDATED)

    By arxiv.org
    Published On ::

    Gabber and Joseph introduced a ladder diagram between two natural sequences of extensions. Their diagram is used to produce a 'twisted' sequence that is applied to old and new results on extension groups in category $mathcal{O}$.


    Full Article

    nc

    A Forward-Backward Splitting Method for Monotone Inclusions Without Cocoercivity. (arXiv:1808.04162v4 [math.OC] UPDATED)

    By arxiv.org
    Published On ::

    In this work, we propose a simple modification of the forward-backward splitting method for finding a zero in the sum of two monotone operators. Our method converges under the same assumptions as Tseng's forward-backward-forward method, namely, it does not require cocoercivity of the single-valued operator. Moreover, each iteration only requires one forward evaluation rather than two as is the case for Tseng's method. Variants of the method incorporating a linesearch, relaxation and inertia, or a structured three operator inclusion are also discussed.


    Full Article

    nc

    Extremal values of the Sackin balance index for rooted binary trees. (arXiv:1801.10418v5 [q-bio.PE] UPDATED)

    By arxiv.org
    Published On ::

    Tree balance plays an important role in different research areas like theoretical computer science and mathematical phylogenetics. For example, it has long been known that under the Yule model, a pure birth process, imbalanced trees are more likely than balanced ones. Therefore, different methods to measure the balance of trees were introduced. The Sackin index is one of the most frequently used measures for this purpose. In many contexts, statements about the minimal and maximal values of this index have been discussed, but formal proofs have never been provided. Moreover, while the number of trees with maximal Sackin index as well as the number of trees with minimal Sackin index when the number of leaves is a power of 2 are relatively easy to understand, the number of trees with minimal Sackin index for all other numbers of leaves was completely unknown. In this manuscript, we fully characterize trees with minimal and maximal Sackin index and also provide formulas to explicitly calculate the number of such trees.


    Full Article

    nc

    A Class of Functional Inequalities and their Applications to Fourth-Order Nonlinear Parabolic Equations. (arXiv:1612.03508v3 [math.AP] UPDATED)

    By arxiv.org
    Published On ::

    We study a class of fourth order nonlinear parabolic equations which include the thin-film equation and the quantum drift-diffusion model as special cases. We investigate these equations by first developing functional inequalities of the type $ int_Omega u^{2gamma-alpha-eta}Delta u^alphaDelta u^eta dx geq cint_Omega|Delta u^gamma |^2dx $, which seem to be of interest on their own right.


    Full Article

    nc

    On the zeros of the Riemann zeta function, twelve years later. (arXiv:0806.2361v7 [math.GM] UPDATED)

    By arxiv.org
    Published On ::

    The paper proves the Riemann Hypothesis.


    Full Article

    nc

    Surjective endomorphisms of projective surfaces -- the existence of infinitely many dense orbits. (arXiv:2005.03628v1 [math.AG])

    By arxiv.org
    Published On ::

    Let $f colon X o X$ be a surjective endomorphism of a normal projective surface. When $operatorname{deg} f geq 2$, applying an (iteration of) $f$-equivariant minimal model program (EMMP), we determine the geometric structure of $X$. Using this, we extend the second author's result to singular surfaces to the extent that either $X$ has an $f$-invariant non-constant rational function, or $f$ has infinitely many Zariski-dense forward orbits; this result is also extended to Adelic topology (which is finer than Zariski topology).


    Full Article

    nc

    On the partitions into distinct parts and odd parts. (arXiv:2005.03619v1 [math.CO])

    By arxiv.org
    Published On ::

    In this paper, we show that the difference between the number of parts in the odd partitions of $n$ and the number of parts in the distinct partitions of $n$ satisfies Euler's recurrence relation for the partition function $p(n)$ when $n$ is odd. A decomposition of this difference in terms of the total number of parts in all the partitions of $n$ is also derived. In this context, we conjecture that for $k>0$, the series

    $$

    (q^2;q^2)_infty sum_{n=k}^infty frac{q^{{kchoose 2}+(k+1)n}}{(q;q)_n}

    egin{bmatrix}

    n-1\k-1

    end{bmatrix}

    $$ has non-negative coefficients.


    Full Article

    nc

    Groups up to congruence relation and from categorical groups to c-crossed modules. (arXiv:2005.03601v1 [math.CT])

    By arxiv.org
    Published On ::

    We introduce a notion of c-group, which is a group up to congruence relation and consider the corresponding category. Extensions, actions and crossed modules (c-crossed modules) are defined in this category and the semi-direct product is constructed. We prove that each categorical group gives rise to c-groups and to a c-crossed module, which is a connected, special and strict c-crossed module in the sense defined by us. The results obtained here will be applied in the proof of an equivalence of the categories of categorical groups and connected, special and strict c-crossed modules.


    Full Article

    nc

    Steiner symmetry in the minimization of the principal positive eigenvalue of an eigenvalue problem with indefinite weight. (arXiv:2005.03581v1 [math.AP])

    By arxiv.org
    Published On ::

    In cite{CC} the authors, investigating a model of population dynamics, find the following result. Let $Omegasubset mathbb{R}^N$, $Ngeq 1$, be a bounded smooth domain. The weighted eigenvalue problem $-Delta u =lambda m u $ in $Omega$ under homogeneous Dirichlet boundary conditions, where $lambda in mathbb{R}$ and $min L^infty(Omega)$, is considered. The authors prove the existence of minimizers $check m$ of the principal positive eigenvalue $lambda_1(m)$ when $m$ varies in a class $mathcal{M}$ of functions where average, maximum, and minimum values are given. A similar result is obtained in cite{CCP} when $m$ is in the class $mathcal{G}(m_0)$ of rearrangements of a fixed $m_0in L^infty(Omega)$. In our work we establish that, if $Omega$ is Steiner symmetric, then every minimizer in cite{CC,CCP} inherits the same kind of symmetry.


    Full Article

    nc

    A reaction-diffusion system to better comprehend the unlockdown: Application of SEIR-type model with diffusion to the spatial spread of COVID-19 in France. (arXiv:2005.03499v1 [q-bio.PE])

    By arxiv.org
    Published On ::

    A reaction-diffusion model was developed describing the spread of the COVID-19 virus considering the mean daily movement of susceptible, exposed and asymptomatic individuals. The model was calibrated using data on the confirmed infection and death from France as well as their initial spatial distribution. First, the system of partial differential equations is studied, then the basic reproduction number, R0 is derived. Second, numerical simulations, based on a combination of level-set and finite differences, shown the spatial spread of COVID-19 from March 16 to June 16. Finally, scenarios of unlockdown are compared according to variation of distancing, or partially spatial lockdown.


    Full Article

    nc

    Removable singularities for Lipschitz caloric functions in time varying domains. (arXiv:2005.03397v1 [math.CA])

    By arxiv.org
    Published On ::

    In this paper we study removable singularities for regular $(1,1/2)$-Lipschitz solutions of the heat equation in time varying domains. We introduce an associated Lipschitz caloric capacity and we study its metric and geometric properties and the connection with the $L^2$ boundedness of the singular integral whose kernel is given by the gradient of the fundamental solution of the heat equation.


    Full Article