Test User

Send a Message

Blogs RSS


BV Testing for
iPhone/iPad


BV Testing for
Android


Friends
This user does not have any friends yet...


About Me
My Store Description 2

https://discoveryprovider.audius.co/v1/users/nlGNe/tracks?app_name=thechopstars

https://anchor.fm/s/31ae2a0/podcast/rss

https://rss.podomatic.net/rss/djdetroit.podomati... Read More
 

BV Testing


https://www.blackvibes.com/bvtesting
 

Test Blog Name 2


Upgrades Available

   

Upgrades Available

This is just a tes


Send Blog   ·     Share on Facebook   ·     Bookmark on Delicious

April Events.2023

   

April Events.2023



With the majority COVID-19 restrictions lifted, events in Puerto Rico are coming back thick and fast. Highlights for April include: Puerto Rico Comic Con, Easter and the Re-enactment of the Battle 1797

April 15 -17, Puerto Rico Comic Con, San Juan
The Puerto Rico Comic Con returns to the Puerto Rico Convention Center in San Juan for a weekend of Cosplay and the chance to meet popular actors from SciFi and more,
For up-to-date information on this years Puerto Rico Comic Con, check out their Facebook Page

n

April 15 & 17, Good Friday & Easter Sunday, Island Wide
Good Friday is an island wide Holiday here in Puerto Rico, so the majority of businesses will be closed. You can expect beaches to be extremely busy (weather permitting). Towns around the island will have special church services and Passion Plays through their streets, including Old San Juan

For Easter Sunday more businesses will be open and restaurants / hotels will be offering special Easter Brunch / Lunch menus

April 22 - 24, Re-enactment of the Battle of 1791, Old San Juan
The Regimiento Fijo de Puerto Rico and fellow re-enactors will transport you back to 1797 with their period costumes and weapons.n Events over the weekend will take place around Old san Juan with most events taking place at the Casa Blanca Museum and El Morro Fort. This is a very cool event suitable for the whole family.n
For a schedule of events check out our article here

More events happening in April

April 8 - 17, La Feria Agricola & Safari Drive, Lares
The Western Hay and Rice Farm in Lares will be hosting a Driving Safari through various agricultural and animal areas, including exotic animals and moreyou will take a driving tour through different areas filled with a lot of info.
Check out their tickets page for more information

April 16. Free Admission to Forts, Old San Juan
To commemorate National Park Week , both El Morro and San Cristobal Forts in Old San Juan will be free

April 22 - 23, San Juan al Aire Libre, Old San Juan
This popular event returns with various streets closed off to traffic so that restaurants can offer open air dining along with local artisans and live music at Plaza San Jose and Plaza del Armas.
For more information and a list of restaurants and streets that will be closed check out San Juan's Facebook page

For more news on events happening in April and the rest of the year; check out our 'What's On Calendar', Twitter Page and Facebook Page

Note: All events are subject to change (especially during the current COVID-19 pandemic), so contact the event organizers for up to date information. Discovering Puerto Rico is not responsible for any schedule changes

Resource: Local media, PR Tourism Co.
The post April Events first appeared on Discovering Puerto Rico.

via: https://www.discoveringpuertorico.com/april-events


Send Blog   ·     Share on Facebook   ·     Bookmark on Delicious

Event buzz (May/June 2022).2

   

Event buzz (May/June 2022).2

Essential info about what's happening across the region to help you make the most of May and June!

The post Event buzz (May/June 2022) appeared first on Caribbean Beat Magazine.

via: https://www.caribbean-beat.com/issue-170/event-buzz-may-june-202


Send Blog   ·     Share on Facebook   ·     Bookmark on Delicious

May Events 2023

   

May Events 2023
Pigeon Park, Old San Juan

Summer is fastly approaching here in Puerto Rico. School holidays start towards the end of the month and locals and visitors are looking forward to spending some quality time with friends and family. It is a great month for all kinds of festivals and family activities and highlights include: A taste of Rum, Festival Tierra Adentro and more...

May 28, A Taste of Rum, Old San Juan
The annual celebration of the islands rum production takes place at Bahia Urbana Pier 6 in Old San Juan. Enjoy a selection of the island's best rums, live music, educational activities and food at this popular event.

More info at a Taste of Rum website.n

May 12 - 15, 35th Festival Tierra Adentro, Utuado
The 35th Festival Tierra Adentro is an Agricultural and Craft Festival that takes place at the University of Puerto Rico Utuado campus. There will be seminars, educational activities, local artisans, live music, food and more

Also happening in May

May 6, Vega Baja Gastronnmico
Food and music event taking place in the towns Plaza de Recreo Josn Francisco Nnter. The fun starts at 6pm

May 27 to 29, Festival Del Chapnn, Naguabo
The annual Chapnn (trunkfish) Festival is a popular seafood event that takes place along the along the Malecon in Naguabo. Enjoy tasty snacks featuring Chapin along with live music and family activities

May 28, Mojito Fest, San Juan
Another rum event this time celebrating the Mojito.n The Puerto Rico Convention Center will host this years Mojito Fest featuring around 40 restaurants' showcasing their best dishes and best mojitos.

More info on their Facebook Pagen

For more news on events happening in May and the rest of the year; check out our 'What's On Calendar', Twitter Page and Facebook Page

Note: All events are subject to change, so contact the event organizers for up to date information. Discovering Puerto Rico is not responsible for any schedule changes

Resource: local media, PR Tourism Co.
The post May Events first appeared on Discovering Puerto Rico.

via: https://www.discoveringpuertorico.com/may-events


Send Blog   ·     Share on Facebook   ·     Bookmark on Delicious

May Events 2024

   

May Events 2024
Pigeon Park, Old San Juan

Summer is fastly approaching here in Puerto Rico. School holidays start towards the end of the month and locals and visitors are looking forward to spending some quality time with friends and family. It is a great month for all kinds of festivals and family activities and highlights include: A taste of Rum, Festival Tierra Adentro and more...

May 28, A Taste of Rum, Old San Juan
The annual celebration of the islands rum production takes place at Bahia Urbana Pier 6 in Old San Juan. Enjoy a selection of the island's best rums, live music, educational activities and food at this popular event.

More info at a Taste of Rum website.n

May 12 - 15, 35th Festival Tierra Adentro, Utuado
The 35th Festival Tierra Adentro is an Agricultural and Craft Festival that takes place at the University of Puerto Rico Utuado campus. There will be seminars, educational activities, local artisans, live music, food and more

Also happening in May

May 6, Vega Baja Gastronnmico
Food and music event taking place in the towns Plaza de Recreo Josn Francisco Nnter. The fun starts at 6pm

May 27 to 29, Festival Del Chapnn, Naguabo
The annual Chapnn (trunkfish) Festival is a popular seafood event that takes place along the along the Malecon in Naguabo. Enjoy tasty snacks featuring Chapin along with live music and family activities

May 28, Mojito Fest, San Juan
Another rum event this time celebrating the Mojito.n The Puerto Rico Convention Center will host this years Mojito Fest featuring around 40 restaurants' showcasing their best dishes and best mojitos.

More info on their Facebook Pagen

For more news on events happening in May and the rest of the year; check out our 'What's On Calendar', Twitter Page and Facebook Page

Note: All events are subject to change, so contact the event organizers for up to date information. Discovering Puerto Rico is not responsible for any schedule changes

Resource: local media, PR Tourism Co.
The post May Events first appeared on Discovering Puerto Rico.

via: https://www.discoveringpuertorico.com/may-events


Send Blog   ·     Share on Facebook   ·     Bookmark on Delicious

Bridging the divide | Portfolio 2

   

Bridging the divide | Portfolio 2

This year, Caribbean artists will have their biggest ever presence at two of the world's most significant contemporary art events - the Venice Biennale and documenta fifteen. Janine Mendes-Franco learns more

The post Bridging the divide | Portfolio appeared first on Caribbean Beat Magazine.

via: https://www.caribbean-beat.com/issue-170/bridging-the-divide-portfoli


Send Blog   ·     Share on Facebook   ·     Bookmark on Delicious

   

Episode 15: The DJ ARCH Total Spectrum Show (TSS) v12 Tribal House

I'm back with another episode! Check out this new Tribal House mix guaranteed to jumpstart any outdoor activity this summer. Play this quality mix and turn up the volume as you and your guest move and groove to the fist pumping sounds. Donations to this podcast are greatly appreciated. You can donate here: https://bit.ly/djarchpaypal https://bit.ly/djarchcashapp 

https://bit.ly/djarchmerchstore

https://bit.ly/djarchradio

https://bit.ly/fleetedmradio

https://bit.ly/djarchontwitch


https://bit.ly/djarchliveonmixcloud


https://bit.ly/djarchlinktree


 
My mobile app available FREE

http://bit.ly/djarchapp


via: https://www.podomatic.com/podcasts/deejarch/episodes/2022-06-17T22_15_51-07_0


Send Blog   ·     Share on Facebook   ·     Bookmark on Delicious

   

Ben Cohen, manager of the Swift team at Apple, joins John on this WWDC22 special to discuss Swift 5.7, how generics have been made more powerful and easy to use, and how the language is expected to evolve towards Swift 6.
Sponsors

  • Bitrise: Rock-solid continuous integration for your Swift projects. Go to bitrise.io/swift to get started for free.
  • NordVPN: Get an exclusive discount on NordVPN's excellent VPN service, by going to nordvpn.com/sundell. They even have a 30-day money-back guarantee.Links
  • Ben on Twitter
  • John on Twitter
  • Swift Async Algorithms
  • Swift Collections
  • Using the new 'some' and 'any' keywords
  • Type erasure
  • "What's New in Swift", from WWDC22
  • "Embracing Swift Generics", from WWDC22
  • WeatherKit
  • Regex Literals
  • RegexBuilder
  • Result builders
  • App Intents
  • Sourcery
  • Doug Gregor's "Eliminate data races using Swift Concurrency" talk
  • Ben's Swift concurrency talk from WWDC21
  • Grand Central Dispatch
  • Swift Distributed Actors
  • Connecting async/await to other Swift code
  • The Swift Mentorship Program
  • Intro and outro music by Dariusz Dziuk

    via: https://www.swiftbysundell.com/podcast/11


  • Send Blog   ·     Share on Facebook   ·     Bookmark on Delicious

       

    Combining Swift's flexible generics system with protocol-oriented programming can often lead to some really powerful implementations, all while minimizing code duplication and enabling us to establish clearly defined levels of abstraction across our code bases. However, when writing that sort of code before Swift 5.7, it's been very common to run into the following compiler error:
    Protocol 'X' can only be used as a generic constraint because it
    has Self or associated type requirements.Let's take a look at how Swift 5.7 (which is currently in beta as part of Xcode 14) introduces a few key new features that aim to make the above kind error a thing of the past.
    Opaque parameter typesLike we took a closer look at in the Q&A article "Why can't certain protocols, like Equatable and Hashable, be referenced directly?", the reason why it's so common to encounter the above compiler error when working with generic protocols is that as soon as a protocol defines an associated type, the compiler starts placing limitations on how that protocol can be referenced.
    For example, let's say that we're working on an app that deals with various kinds of groups, and to be able to reuse as much of our group handling code as possible, we've chosen to define our core Group type as a generic protocol that lets each implementing type define what kind of Item values that it contains:
    protocol Group {
    associatedtype Item

    var items: [Item] { get }
    var users: [User] { get }
    }Now, because of that associated Item type, we can't reference our Group protocol directly - even within code that has nothing to do with a group's items, such as this function that computes what names to display from a given group's list of users:
    // Error: Protocol 'Group' can only be used as a generic constraint
    // because it has Self or associated type requirements.
    func namesOfUsers(addedTo group: Group) -> [String] {
    group.users.compactMap { user in
    isUserAnonymous(user) ? nil : user.name
    }
    }One way to solve the above problem when using Swift versions lower than 5.7 would be to make our namesOfUsers function generic, and to then do what the above error message tells us, and only use our Group protocol as a generic type constraint - like this:
    func namesOfUsers<T: Group>(addedTo group: T) -> [String] {
    group.users.compactMap { user in
    isUserAnonymous(user) ? nil : user.name
    }
    }There's of course nothing wrong with that technique, but it does make our function declaration quite a bit more complicated compared to when working with non-generic protocols, or any other form of Swift type (including concrete generic types).
    Thankfully, this is a problem that Swift 5.7 neatly solves by expanding the some keyword (that was introduced back in Swift 5.1) to also be applicable to function arguments. So, just like how we can declare that a SwiftUI view returns some View from its body property, we can now make our namesOfUsers function accept some Group as its input:
    func namesOfUsers(addedTo group: some Group) -> [String] {
    group.users.compactMap { user in
    isUserAnonymous(user) ? nil : user.name
    }
    }Just like when using the some keyword to define opaque return types (like we do when building SwiftUI views), the compiler will automatically infer what actual concrete type that's passed to our function at each call site, without requiring us to write any extra code. Neat!
    Primary associated typesSometimes, though, we might want to add a few more requirements to a given parameter, rather than just requiring it to conform to a certain protocol. For example, let's say that we're now working on an app that lets our users bookmark their favorite articles, and that we've created a BookmarksController with a method that lets us pass an array of articles to bookmark:
    class BookmarksController {
    ...

    func bookmarkArticles(_ articles: [Article]) {
    ...
    }
    }However, not all of our call sites might store their articles using an array. The following ArticleSelectionController, for instance, uses a ‌dictionary to keep track of what articles that have been selected for what IndexPath within a UITableView or UICollectionView. So, when passing that collection of articles to our bookmarkArticles method, we first need to manually convert it into an array - like this:
    class ArticleSelectionController {
    var selection = [IndexPath: Article]()
    private let bookmarksController: BookmarksController
    ...

    func bookmarkSelection() {
    bookmarksController.bookmarkArticles(Array(selection.values))
    ...
    }
    }But if we instead wanted to update that bookmarkArticles method to work well for any kind of Collection that contains Article values, then we couldn't simply change its parameter type to some Collection, since that wouldn't be enough to specify that we're looking for a collection that has a specific Element type as input.
    We could, however, once again use a set of generic type constraints to solve that problem:
    class BookmarksController {
    ...

    func bookmarkArticles<T: Collection>(
    _ articles: T
    ) where T.Element == Article {
    ...
    }
    }Again, nothing wrong with that - but Swift 5.7 once again introduces a much more lightweight way to express the above kind of declaration, which works the exact same way as when specializing a concrete generic type (such as Array<Article>). That is, we now can simply tell the compiler what Element type that we'd like our input Collection to contain by adding that type within angle brackets right after the protocol name:
    class BookmarksController {
    ...

    func bookmarkArticles(_ articles: some Collection<Article>) {
    ...
    }
    }Very cool! We can even nest those kinds of declarations - so if we wanted to make our BookmarksController capable of bookmarking any kind of value that conforms to a generic ContentItem protocol, then we could specify some ContentItem as our collection's expected Element type, rather than using the concrete Article type:
    protocol ContentItem: Identifiable where ID == UUID {
    var title: String { get }
    var imageURL: URL { get }
    }

    class BookmarksController {
    ...

    func bookmark(_ items: some Collection<some ContentItem>) {
    ...
    }
    }The above works thanks to a new Swift feature called primary associated types, and the fact that Swift's Collection protocol declares Element as such an associated type, like this:
    protocol Collection<Element>: Sequence {
    associatedtype Element
    ...
    }Of course, being a proper Swift feature, we can also use primary associated types within our own protocols as well, using the exact same kind of syntax.
    Existentials and the 'any' keywordFinally, let's take things one step further by also turning our ArticleSelectionController into a generic type that can be used to select any ContentItem-conforming value, rather than just articles. As we're now looking to mix multiple concrete types that all conform to the same protocol, the some keyword won't do the trick - since, like we saw earlier, it works by having the compiler infer a single concrete type for each call site, not multiple ones.
    This is where the new any keyword (which was introduced in Swift 5.6) comes in, which enables us to refer to our ContentItem protocol as an existential. Now, doing that does have certain performance and memory implications, as it effectively works as an automatic form of type erasure, but in situations where we want to be able to dynamically store a heterogeneous collection of elements, it can be incredibly useful.
    For example, by simply using any ContentItem as our selection dictionary's value type, we'll now be able to store any value conforming to that protocol within that dictionary:
    class ContentSelectionController {
    var selection = [IndexPath: any ContentItem]()
    private let bookmarksController: BookmarksController
    ...

    func bookmarkSelection() {
    bookmarksController.bookmark(selection.values)
    ...
    }
    }However, making that change does introduce a new compiler error, since our BookmarksController is expecting to receive a collection that contains values that all have the exact same type - which isn't the case within our new ContentSelectionController implementation.
    Thankfully, fixing that issue is as simple as replacing some ContentItem with any ContentItem within our bookmark method declaration:
    class BookmarksController {
    ...

    func bookmark(_ items: some Collection<any ContentItem>) {
    ...
    }
    }We're even able to mix any and some references, and the compiler will automatically help us translate between the two. For example, if we wanted to introduce a second, single-element bookmark method overload, which our first one then simply calls, then we could do so like this (even though the first method's items collection contains any ContentItem and the second method accepts some ContentItem):
    class BookmarksController {
    ...

    func bookmark(_ items: some Collection<any ContentItem>) {
    for item in items {
    bookmark(item)
    }
    }

    func bookmark(_ item: some ContentItem) {
    ...
    }
    }Again, it's important to emphasize the using any does introduce type erasure under the hood, even if it's all done automatically by the compiler - so using static types (which is still the case when using the some keyword) is definitely the preferred way to go whenever possible.
    ConclusionSwift 5.7 doesn't just make Swift's generics system more powerful, it arguably makes it much more accessible as well, as it reduces the need to use generic type constraints and other more advanced generic programming techniques just to be able to refer to certain protocols.
    Generics is definitely not the right tool for every single problem, but when it turns out to be, being able to use Swift's generics system in a much more lightweight way is definitely a big win.
    I hope that you found this article useful. If you have any questions, comments, or feedback, then feel free to reach out via either Twitter or email. For more information about these new generics features, I recommend watching the excellent "What's new in Swift" and "Embrace Swift generics" sessions from this year's WWDC.
    Thanks for reading!

    via: https://www.swiftbysundell.com/articles/referencing-generic-protocols-with-some-and-any-keyword


    Send Blog   ·     Share on Facebook   ·     Bookmark on Delicious

    Swift 5.7's new optional unwrapping syntax

       

    Swift 5.7 introduces a new, more concise way to unwrap optional values using if let and guard let statements. Before, we always had to explicitly name each unwrapped value, for example like this:
    class AnimationController {
    var animation: Animation?

    func update() {
    if let animation = animation {
    // Perform updates
    ...
    }
    }
    }But now, we can simply drop the assignment after our if let statement, and the Swift compiler will automatically unwrap our optional into a concrete value with the exact same name:
    class AnimationController {
    var animation: Animation?

    func update() {
    if let animation {
    // Perform updates
    ...
    }
    }
    }Neat! The above new syntax also works with guard statements:
    class AnimationController {
    var animation: Animation?

    func update() {
    guard let animation else {
    return
    }

    // Perform updates
    ...
    }
    }It can also be used to unwrap multiple optionals all at once:
    struct Message {
    var title: String?
    var body: String?
    var recipient: String?

    var isSendable: Bool {
    guard let title, let body, let recipient else {
    return false
    }

    return ![title, body, recipient].contains(where: \.isEmpty)
    }
    }A small, but very welcome feature. Of course, we still have the option to explicitly name each unwrapped optional if we wish to do so - either for code style reasons, or if we want to give a certain optional a different name when unwrapped.

    via: https://www.swiftbysundell.com/articles/swifts-new-shorthand-optional-unwrapping-synta


    Send Blog   ·     Share on Facebook   ·     Bookmark on Delicious