Author: Michael G

One great app for all solutions. If you want to quality and branded shopping, there is a new launch on the way called Vizhil. If you need a quick ride or want to go on an immediate trip, or if you are hungry and want spicy or delicious food to eat, Vizhil is for you. If you are having a problem in your household and you need an immediate solution, join us. We also work in the digital industry, and we have given you a digital service—the one super app for your daily needs called Vizhil.

Shrouding the Heavens, 遮天, Shrounding the Heavens
At the edge of the dark and frozen universe, nine giant dragon corpses were bound in ancient bronze coffins. It seemed they had been there since the birth of the universe. This amazing view was captured by a spacecraft hovering in outer space.
The nine dragons and the mysterious bronze coffin made people wonder whether they went back to ancient times or had just reached another shore in the universe. A giant mythical world opens up, where immortality gradually emerges and paranormal events continue to occur.
Many people began to find their own traces (Dao) in these mythical realms. Their passion was like the turbulent and unrelenting waves of the sea. The heat in their blood was like an erupting volcano. Their desire for power and immortality drags them into the abyss without realizing it.
#ShroudingtheHeaven
#遮天
#69
#ShroundingtheHeavens
#Zhetian

Exam D-Day and these pupils opened their results in front of the media

https://accounts.eclipse.org/users/brigadecitrine
https://www.prodesigns.com/wordpress-themes/support/users/brigadecitrine
http://taylorhicks.ning.com/profile/Brigadecitrinee
https://answers.ea.com/t5/user/viewprofilepage/user-id/40960351
https://www.wikidata.org/wiki/User:BrigadCitrine

Configuration management is one of the best features introduced in Drupal. It allows developers to easily push configuration changes from development to staging, and finally to production environments. However, some configurations are environment-specific. For instance, modules like Devel, Kint, Views UI, and Google Tag are only enabled in development environments and not in production.
Fortunately, the Configuration Split module offers a solution by storing configurations in a separate directory, allowing for environment-specific imports. In this article, you’ll learn how to split configurations across different websites using this powerful Drupal 10 module.

Setup and using the Configuration Split module
Installing the Drupal Configuration Split module is like installing any other contributed module. Use composer to install it since it automatically installs all the necessary dependencies. Open the terminal, within the project and enter the command.
$ composer require drupal/config_splitCreate the split configuration
Once installed and enabled, we can create one or more “splits” to keep our configuration file in a separate folder.

Go to Admin > Configuration > Development > Configuration Split Settings
Click Add Configuration Split Setting
Enter a Label
In the folder field, enter the folder name relative to the Docroot.
The path will specify the folder inside which the split configurations should be stored.

../config/dev_splitMake sure the machine name of your split is the same as the folder name.

You can keep the split active or inactive by default. These settings can be overridden by settings.php.

Choose the module you want to split. In our case – the Devel Module.

Since we are pushing the module to a separate config split folder, We have to partially split core.extension.yml file, which stores information about what modules must be installed on your site.

Click Save.
The config files of the selected module will also be sent to the same folder once you export the config split.
The module also enables users to select any particular config file to be split.

Activate a Split
Once the split is created, it needs to be activated to carry out a split. The Drupal 10 Configuration Split module does not provide a UI for this purpose, but instead, we can modify our settings.php file to activate the split:
$config[‘config_split.config_split.dev_split’][‘status’] = TRUE;Where, dev_split is the machine name of the split we created earlier.
Now, export your configuration using drush cex. You can see the config_split settings getting updated and the module getting removed from your core.extension file, along with respective settings files.
To export the configs selected in the dev_split, you have to run a different command, i.e.
drush config-split: export “split_name”In our case it would be, drush config-split:export dev_split.
Now you can see the files selected in dev_split getting exported to the dev_split directory. 

For our Development split, we need to have it activated in the development environment, but not in production. To do so, we add the following to our settings.php on our development environment.

$config[‘config_split.config_split.development’][‘status’] = TRUE;
For the Production site we won’t add this code in the settings file, or we can also disable it explicitly by using below code:

config[‘config_split.config_split.development’][‘status’] = FALSE;Activate split based on environment
You can also specify which split should be active in a certain environment by adding a condition in settings.php as shown below:
if (isset($_ENV[‘AH_SITE_ENVIRONMENT’])) {
   switch ($_ENV[‘AH_SITE_ENVIRONMENT’])
   {
     case ‘develop’:
    $config[‘config_split.config_split.dev_split’][‘status’] = TRUE;
    break;
     case ‘live’:
    $config[‘config_split.config_split.prod_split’][‘status’] = TRUE;
    break;
   }
 }The above code will activate dev_split in the development (‘develop’) environment and prod_split in the production (‘live’) environment.
Final Thoughts
The Configuration Split Module is a fantastic feature introduced in Drupal’s configuration management. By splitting up configurations based on environments, you can use the module only in certain environments, based on your needs. We hope you found this article helpful. For more interesting articles on Drupal and everything technology, please bookmark our blog and come back for more!

In this episode, we will upload a CSV file but need to pass it into a background job. This can prove to be difficult based on the hosting infrastructure so we’ll explore some mechanisms to work around them. We’ll also look to optimize Solid Queue to handle the large number of jobs. https://www.driftingruby.com/episodes/processing-large-jobs

Imagine you created your very first app. You developed the concept, worked
tirelessly on the key features, design, tested it and fixed the bugs. The
moment has finally arrived and you are ready to share your creation with the
world. But how? App stores are a great tool for sharing apps with end users,
but each store has its own unique requirements, upload and approval process
and for some, such as the Google Play Store, you need to pay a developer
registration fee and create an account including a physical address to even
get started.

If you are a new developer, trying to bring your first app to market, the
learning curve can feel a little steep. Once you have done it the first
time, one could argue that the process feels somewhat familiar. However with
each new release, each new update for your app, comes additional manual
steps to follow. 

So, if you were faced with the choice of navigating the app deployment and
upload process with one app store, or doing it several times over with
different app stores, with unique requirements and deployment processes,
what would you choose? 

For most new Android developers, the answer is simple, just get the app on
Google Play and call it a day. And the reality is that the conversation
often stops there for many mainstream Android app developers, feeding the
monopoly and strengthening the hold Big Tech has on the market. 

F-Droid is of course an excellent FOSS based alternative for those looking
for a privacy-focused, community-led app store. But we are not the only app
store solution developers could choose from. So what if there was a way to
open up the market for new and existing developers by creating some fair and
healthy competition? What if we could streamline the app deployment process,
making it easier for developers to upload their APK to multiple stores at
the push of a button? Well, this is exactly what F-Droid will be focusing on
creating, for our initial contribution to the
Mobifree project.

User Research to Discover Pain Points and Potential Solutions

To get started we began with a series of user research interviews to gain a
deeper perspective on the current challenges developers and alternative app
stores have, when it comes to app deployment. We paid particular attention
to various compensation models favored by the developers and explored how to
incorporate easy payment options into our solution

The results of the study were clear, developers are interested in listing
their app on alternative app stores, but the app deployment and upload
process to multiple stores is not straightforward. This results in a
centralized market, with the majority of mainstream apps simply ending up on
one app store. If we want to decentralize the market, and create more choice
for developers and end users, then we need to make it easier for developers
to list their app on multiple stores, streamline the update process, and
consider developer compensation in our solution as well.

After successfully identifying the pain points, some market research
participants pointed out a FOSS-based solution on the market that solves
some of them – Fastlane. Fastlane is an
open-source platform aimed at simplifying Android and iOS deployment, by
helping developers automate their development and release workflow. We had
already been exploring how we could potentially use a Fastlane framework for
our idea, so when some of our study participants mentioned they were already
implementing Fastlane tools to automate their Google Play launches and
updates, we took that as a good sign.

However we noticed some limitations within the Fastlane framework. Their
main focus is automating the app deployment, upload and review process for
the two biggest players – Google Play and the Apple App Store. Our goal is
to create a workflow that automatically deploys and uploads to multiple
stores simultaneously, helping diversify the market.

In addition to Fastlane´s app upload feature, the Fastlane core team and
community have created a nice list of additional
plug-ins for developers to further
automate various aspects of the app development, screenshot generation,
testing, uploading and the updating process.

Once we begin the development process, we will have a clearer idea of how we
can lean on Fastlane´s existing framework, for our own solution. 

Accounting for Financial Sustainability

Our aim is to create a solution that is streamlined and straightforward,
encouraging a decentralization of the app market in general. But in order to
create a solution that will be mainstream enough to make in-roads into the
hold Big Tech has on the market, we need to consider how to streamline the
payment processes as well, making it easy for developers receive financial
compensation. Therefore, we included compensation model preferences in our
interviews with developers to gain insight into their values and
preferences.

When it came to preferred compensation models such as pay-to-download,
in-app payments, donations or subscription-based models, it became clear
that the preferred model was highly dependent on the type of app and user
base. 

Some developers we interviewed noted a preference towards the old school
pay-to-download approach. With this compensation model, users pay a one-time
fee to download the app from an app store. The transaction occurs before the
users has access to the app.

For app stores like Google Play, this is straightforward as they have their
own built in licensing service where distributing and verifying license keys
is handled internally and the tool is of course proprietary. 

If we want to create a solution that includes a pay-to-download option for
developers who are uploading their apps to multiple app stores
simultaneously, integrating with payment gateways like PayPal or Stripe can
provide a straightforward approach to handle transactions externally. Users
can purchase the app through these gateways and receive a download link or
licensing key upon successful payment. Furthermore, to streamline the
payment and licensing key distribution process, developers can leverage
providers that offer unified APIs. These unified APIs simplify the
integration by providing a single point of access to manage payments and
distribute licensing keys across various platforms, ensuring a more
efficient and cohesive user experience.

After pay-to-download, several developers pointed towards a
subscription-based model preference. In this case, they cited regular
maintenance and storage expenses they carry as a company, as the reason for
their decision. Subscription based compensation models often include a free
trial period, then after that time limit has been reached, a payment
occurs. We also heard the “freemium” model being used frequently, where some
features are free, while others come at a cost. Subscription based models
are considered a type of in-app payment, since the transaction is usually
repetitive and occurs after the app has been downloaded and installed.

Within the FOSS community, donation-based models are regularly adopted to
improve access to technology, while securing financial sustainability of
FOSS-based projects. Liberapay is a great
FOSS-based example, providing a way to help facilitate regular, reoccurring
donation payments, in a similar way to subscription model.

Open Collective offers similar services and
is also FOSS-based. However, Open Collective offers more advanced financial
management tools for its users, and is geared towards larger projects with
more complex needs. Additionally, they are more focused on individually
occurring payments, rather than recurring ones. However, this is also an
option. Several developers and app stores told us that prefer in-app
payment models, because it gives them more freedom and flexibility for
developers and end users alike. In many cases in-app payments include an SDK
which is built into the APK file. This enables in-app payments to occur. The
SDK typically integrates with a payment gateway such as Stripe or PayPal or
a service provider. The SDK also includes UI components for payments,
supports various payment methods such as credit cards and digital wallets,
and also handles the transaction management. Finally we discussed in-app
advertising as a potential revenue source. There are of course inherent
privacy issues with advertising models that allow user tracking, so the
general consensus was that if in-app advertising models are used, they
should be done so with caution. Not only are privacy and data protection
founding principles for both Mobifree and F-Droid, the use of tracking-based
in-app advertising poses a moral dilemma as well. If someone wants to gain
access to an app, but does not have the financial means to purchase it, they
can use it at a different kind of price – their user data. It should be
mentioned that it is possible to include in-app advertising without user
tracking. However the lead conversion ratio drops dramatically, so the
efficacy of this approach is not nearly as high. 

Making sense of it all

At the end of the day, finding a streamlined approach for app distribution
that considers diverse compensation model options for developers and users
is a tall order. However motivation and support for the concept is high,
from both Mobifree partners, F-Droid contributors and the FOSS community in
general.

We are looking forward to taking you on the journey with us as we break
ground on this project in the coming months. Stay tuned to our blog for
future updates and if you would like to contribute to our project, feel free
to reach out at mailto:team@f-droid.org.

That sure is a big news drop for a random Tuesday. A federal judge ruled that Google violated US antitrust law by maintaining a monopoly in the search and advertising markets. “After having carefully considered and weighed the witness testimony and evidence, the court reaches the following conclusion: Google is a monopolist, and it has acted as one to maintain its monopoly,” according to the court’s ruling, which you can read in full at the bottom of this story. “It has violated Section 2 of the Sherman Act.” ↫ Lauren Feiner at The Verge Among many other things, the judge mentions Google’s own admissions that the company can do pretty much whatever it wants with Google Search and its advertisement business, without having to worry about users opting to go elsewhere or ad buyers leaving the Google platform. Studies from inside Google itself made it very clear that Google could systematically make Search worse without it affecting user and/or usage numbers in any way, shape, or form – because users have nowhere else to realistically go. While the ability to raise prices at will without fear of losing customers is a sure sign of being a monopoly, so is being able to make a product worse without fear of losing customers, the judge argues. Google plans to appeal, obviously, and this ruling has nothing yet to say about potential remedies, so what, exactly, is going to change is as of yet unknown. Potential remedies will be handled during the next phase of the proceedings, with the wildest and most aggressive remedy being a potential break-up of Google, Alphabet, or whatever it’s called today. My sights are definitely set on a break-up – hopefully followed by Apple, Amazon, Facebook, and Microsoft – to create some much-needed breathing room into the technology market, and pave the way for a massive number of newcomers to compete on much fairer terms. Of note is that the judge also put yet another nail in the coffin of Google’s various exclusivity deals, most notable with Apple and, for our interests, with Mozilla. Google pays Apple well over 20 billion dollars a year to be the default search engine on iOS, and it pays about 80% of Mozilla’s revenue to be the default search engine in Firefox. According to the judge, such deals are anticompetitive. Mehta rejected Google’s arguments that its contracts with phone and browser makers like Apple were not exclusionary and therefore shouldn’t qualify it for liability under the Sherman Act. “The prospect of losing tens of billions in guaranteed revenue from Google — which presently come at little to no cost to Apple — disincentivizes Apple from launching its own search engine when it otherwise has built the capacity to do so,” he wrote. ↫ Lauren Feiner at The Verge If the end of these deals become part of the package of remedies, it will be a massive financial blow to Apple – 20 billion dollars a year is about 15% of Apple’s total annual operating profits, and I’m also pretty sure those Google billions are counted as part of Tim Cook’s much-vaunted services revenue, so losing it would definitely impact Apple directly where it hurts. Sure, it’s not like it’ll make Apple any less of a dangerous behemoth, but it will definitely have some explaining to do to investors. Much more worrisome, however, is the similar deal Google has with Mozilla. About 80% of Mozilla’s total revenue comes from a search deal with Google, and if that deal were to be dissolved, the consequences for Mozilla, and thus for Firefox, would be absolutely immense. This is something I’ve been warning about for years now, and the end of this deal would be yet another worry that I’ve voiced repeatedly becoming reality, right after Mozilla becoming an advertising company and making Firefox worse in the name of quick profits. One by one, every single concern I’ve voiced about the future of Firefox is becoming reality. Canonical, Fedora, KDE, GNOME, and many other stakeholders – ignore these developments at your own peril.