text:
Nine is a very reliable email client designed to work with all of your accounts. The clean interface and the optional conversation view make reading and replying to email intuitive. One of the coolest features is the ability to customize the notification actions, including an incredibly useful "Mark as read" option. It isn't cheap, but it's only a one-time $14.99 charge for a much-improved email experience that also integrates calendar, contacts, notes, and tasks functionality.
Last, but certainly not least on our list is Zedge. This is a wallpapers, ringtones, notification tones, and alarm tones app that gives you an unbelievable number of options to customize the most basic parts of your device. On top of having an exhaustive collection of things, Zedge also promotes various items during holiday seasons making it easy to theme your phone up for Christmas, Halloween, and other holidays. It's not 100% perfect. It does have the occasional bug and some irritating advertisements. Zedge Premium is a new initiative to provide premium content at a reasonable price. You watch ads or fill out surveys to earn Zedge credits. You can buy them as well with in-app purchases. It's a good way to support the developer and the artists. We also recommend Walli (with an i) for wallpapers.
If you're traveling within a major metropolitan area via either public transportation or personal vehicle, Citymapper can plan all your trip details. It has transit information for dozens of major U.S. cities and international hotspots in Europe, Asia, and Latin America. Further, it offers multiple transportation options for each city, so if you feel like taking the ferry to work one morning, there's nothing stopping you. Its top features include Commute, which lets you set up your daily travel to and from work, and an alert system that uses natural language to describe service delays or cancellations. New Droid Apps
Want to keep your internet activities on the down-low, or simply don't like the idea that the government could be spying on your every move? One of the best Android VPN apps is a great way to prevent that. ExpressVPN offers both a virtual private network, and some advanced features — such as the ability to connect to servers in more than 100 locations around the world.
Your bag of holding for internet content, Pocket saves articles, images, and videos for later reading. We especially like how it reformats articles for more comfortable reading on a mobile device, and how it syncs content to your tablet, phone, and online account. With the close integration between Pocket and the Android sharing tools, you can pocket just about anything from your phone. Android App
Menstruators the world over will rejoice over Clue, a simple app with a beautiful design for tracking your period and predicting when the next will occur. Using the data you enter about your cycle—and other factors—you can use Clue to plan ahead, whether it's for pregnancy or just to keep ahead of your cycle. Reminders and a handy calendar tool can help take the guesswork out of life. Best of all, it's totally gender neutral, and not the expected pink. Droid Apps
Adobe Lightroom is a powerful photo-editing app for mobile that retains many of the features from its desktop counterparts, Lightroom, which earned a three-and-a-half star rating, and Lightroom Classic, a five-star Editors' Choice winner. Some of its standout tools include raw camera file profiles, noise reduction, profile-based lens corrections, and advanced color and lighting sliders. Lightroom also notably syncs all these edits between the mobile and desktop apps.
There are a lot of apps out there that pay lip service to security and privacy, but Signal was built from the ground up with the goal of letting people easily communicate without having to worry about being overheard. The Signal app is a complete phone and SMS client replacement (though it works just fine as a standalone app, too) for sending and receiving encrypted calls and messages. A recent update has greatly improved the app's look and feel, proving that security and usability don't have to be at odds. Droid Apps
If you're looking to learn another language, Duolingo gamifies language learning with bite-sized lessons and a friendly interface. Starting with simple vocabulary and building from there, Duolingo is your guide to learning a new language or brushing up on one you already know. The more you use the app, the more you unlock and—with practice—the more you learn. This free app currently supports Danish, Dutch, French, German, Irish, Italian, Portuguese, Spanish, and Swedish. Or more practical choices, like Esperanto and Klingon.
Everyone needs to file their taxes every year. Most people will probably have an easier time using dedicated tax software (and some might still enjoy preparing them by hand), but more ambitions filers or those with simple tax returns can get away with using a mobile app. Intuit's TurboTax Tax Return App is the best one we reviewed this year. Among its top features are an excellent user interface, support for all major tax forms, and innovative help options. If you get stuck at any point, you can just open up the Virtual Assistant, which keeps a running dialogue of the help topics you searched for, or use SmartLook to connect to a tax expert via video chat.
Game-streaming platforms and subscriptions are all the rage right now, with big-name players such as Apple (Arcade), Google (Stadia), and Microsoft (xCloud) all recently launching some sort of effort. Steam Link (still in beta) allows you to play games from your Steam library directly from your Android phone, with the caveat that both your PC and mobile device must be connected to the same network. Check out our guide on how to stream games on your Android or iOS device.
GetJar's clever draw is to offer premium apps to users for free to generate traffic, and then monetize that traffic with advertising dollars. App developers considering GetJar might be tempted by the virtual currency tie-ins, and the option to target new users with different kinds of promotions. Be warned, though, the submission process might take a while.
Art & DesignAuto & VehiclesBeautyBooks & ReferenceBusinessComicsCommunicationDatingEducationEntertainmentEventsFinanceFood & DrinkHealth & FitnessHouse & HomeLibraries & DemoLifestyleMaps & NavigationMedicalMusic & AudioNews & MagazinesParentingPersonalizationPhotographyProductivityShoppingSocialSportsToolsTravel & LocalVideo Players & EditorsWeather
For passing links, web addresses, or clipboard data between devices, Join is a great option. Setup and customization are easy and Join makes it simple to specify which notifications and actions you want to enable for each device. It even syncs SMS texts to a Chrome browser or the dedicated Windows 10 app. Unlike Pushbullet, it doesn't require a monthly subscription to use its features to the fullest. Our favorite features are its remote screenshot and screen-capture capabilities. Droid App
Initially, we weren't going to put any launchers on this list. Nova Launcher seems to be extend beyond what normal launchers are. It's been around for years, it's been consistently updated, and thus it's never not been a great option for a launcher replacement. It comes with a host of features, including the ability to backup and restore your home screen set ups, icon theming for all of your Android apps, tons of customization elements for the home screen and app drawer, and more. You can even make it look like the Pixel Launcher if you want to. If you go premium, you can tack on gesture controls, unread count badges for apps, and icon swipe actions. Those looking for something simpler may want to try Lawnchair Launcher, Hyperion Launcher, and Rootless Launcher as well. New Droid Apps
You might know Fitbit from its popular fitness trackers, but the app that powers those devices works well on its own, too. Using your just your smartphone (assuming you meet the minimum hardware requirements), this fitness app can count steps and log activities to help you achieve daily goals. There are also social features, so you can compete against your friends. It's a must-have (really, you must have it) for Fitbit users, but also a smart choice for anyone looking to be more active.
Ben Moore is an Analyst for PCMag's software team. He has previously written for Laptop Mag, Neowin.net, and Tom's Guide. Ben holds a degree in New Media and Digital Design from Fordham University at Lincoln Center, where he served as the Editor-in-Chief of The Observer, the student-run newspaper. He spends his free time taking photos and reading b... See Full Bio Android App
Brave Browser offers a host of features aimed at protecting your security and privacy on the web. For instance, it includes built-in blockers for ads, pop-ups, scripts, and third-party cookies. It even implements the HTTPS Everywhere extension, so you can ensure that your connections to sites are secure. The lightweight, minimal design looks great, too. New Droid Apps
With its slick, streamlined interface, Flipboard is one of the best apps for reading the news. With it, you browse the articles, videos, podcasts, and other media that matter most to you. The app's signature magazine-style interface lets you explore the day's headlines in a gorgeous environment. The Daily Edition feature gives you the most important news along with themed stories for each day of the week. Flipboard has been one of our top picks for years, and it's easy to see why. New Droid Apps
Over the years, some titles have been dropped from this list, as they are overshadowed by new contenders or fall behind in updates or features. Newer, better apps have taken their place. Yet, some apps still hang on to the top spot tenaciously. To create a little more space for new blood, we asked our editorial staff which new apps changed their lives in 2019. Here's what stood out:
There's no shortage of Reddit apps on the Google Play store and choosing one over another ultimately comes down to preference, but reddit is fun (RIF) is a great option to try. The default view features a dense, text-heavy layout which puts the best (and worst) of Reddit front and center. There's both a light and dark theme and tons of layout content customization options to try out, even if you don't opt for the paid version. Better yet, there are no ads in either version or RIF and its overall performance is extremely quick. New Droid Apps
Network Analyzer makes it easy to view information about all of the Wi-Fi networks nearby. With a few taps, you can see the strength of networks in the area on a dynamic graph and view detailed information about your connection, such as your IPv4 Address, MAC Address, and Default Gateway IP. You can even run a network query from within the app; it lets you Ping an IP/Domain Name or even check the DNS Server settings. It's the perfect companion to our article on how to find your IP address.
AppsLib was created by Archos, and is the app marketplace for Android devices that couldn't get Google certification, mainly tablets. It comes pre-installed on a number of devices from smaller manufacturers. There are almost 40,000 apps on offer, and each one has been certified as compatible with specific devices. They are categorized, and there's even an adult section, which is PIN protected. You can also pay for apps using PayPal. Droid App
Combined with Google Drive, this is an excellent choice for collaboration, especially given how feature-rich the mobile and web apps are. Once you create a document, you can add people to it, so that they can collaborate. Once they accept the invitation, you can create a multitude of documents — similar to what you can do with Microsoft Office — and have your team collaborate in real time.
You cannot compile a list of the best apps for movies and TV without mentioning Netflix. The service is a social and cultural phenomenon, and the Netflix app is really rather decent. The selection is enormous and the streaming quality is excellent. The biggest advantage of it has over its rivals, however, is the ever-increasing selection of exclusive content and Netflix Originals movies and TV shows. You'll need a paid account to watch though, of course.
As one expects from a wallpaper app, the app is easy to use, with all the wallpapers appropriately structured in each category. Additionally, signing up on the application also syncs all the wallpapers over different devices. Of course, there are millions of wallpapers spread across different apps, but this one is definitely the best Android app for wallpapers.
fuboTV is a great option for any cord-cutting sports fans. This "sports-first, but not sports-only" service offers extensive live sports and entertainment content (85 channels) for all your devices. Whether you want to watch NFL games on Sunday, catch up an MLB game that aired during the day, or even stream a movie on-demand, fuboTV has you covered. fuboTV also offers excellent DVR capabilities and other features for watching events and shows you may have otherwise missed. In testing, streaming live and on-demand shows worked very well.
We don't typically recommend streaming services to people. Everyone has their preferences and saying that one is better than another is a matter of opinion at this point. Except for this collection of Android apps. There's more content there than a human person can watch or listen to in several lifetimes. That includes music videos, educational videos, news videos, reviews, video game let's plays, music (of course), and a whole lot more. YouTube Music should replace Google Play Music eventually. This collection is the best music and video streaming package on mobile as long as they remain tied together. Spotify, Apple Music, and Tidal are also great music streaming services, especially if you want better sounding music.
It's a pretty self-explanatory step. The Google Play Store comes in APK format like any other Android app. You can download APKs from websites, tech blogs, and trusted people on forums or other places. However, for now, APKMirror is probably your best bet for trusted Google Play Store APKs. Here is a short tutorial for downloading the Play Store app:
Remember Flickr? The venerable photo-sharing service is an Editors' Choice web service, and the Android app has a lot to recommend it, too. It's more about the art of photography than the meme- and selfie-packed Instagram. Offering a well-designed interface and excellent photo and video editing tools, Flickr is more valuable than ever. Plus, the app connects you to the vibrant community of photographers on the service. Best of all, it can automatically back up photos from your phone. Free users can upload up to 1,000 photos and a $50 per year subscription gets you unlimited online photo storage. Android App
With millions of apps on the Play Store, searching for the best among them is daunting. Whether you need a great weather app or a new tool to speed up your productivity, there are always dozens available. We've spent hours curating the top Android apps for every purpose, and compiled only the best of them into one list. We've just added a mobility section for the best apps from getting you from A to B in 2019.
Ever feel like there's just too much news to keep up with? Nwsty might well be the app for you. It's aimed at those who don't often read the news, and makes it easy to keep up with the daily headlines without spending too much time on them. Each day, you get six to 10 headlines in your digest that you can quickly and easily read in a matter of only a few minutes. Droid App
The Google Play Store gets frequent updates, which is great news. The not-so-great news is that it can take weeks, or for some people even longer, to get the latest iteration. The basic functionality never changes so being stuck on an older version isn't all that bad. However, we understand the urge to get the latest and greatest version on your device.
You'll find a huge repository of free apps here for various platforms including Android. GetJar is fairly basic, but apps are divided into categories and sub-categories within the store to make it easier to find what you want. You'll also find likes or dislikes and comments on each app from users. GetJar can also connect with Facebook. On the downside, you will encounter sponsored recommendations, but they are clearly marked.
Despite the fact that we are well into the 21st century, paper still persists in offices. But Microsoft Office Lens lets you turn physical documents into digital ones using your Android. It can even capture doodles and notes from a whiteboard. If you want portable document scanning, but aren't keen on getting an Evernote account, this might be the solution for you. Droid Apps
Tracking your period isn't just about knowing the cycle, but also the other factors surrounding it. Eve by Glow lets you track physical and emotional states, which can lead to some important insights when you take the time to interpret your own data. Eve also boasts a vibrant community and a wealth of information about sexual health built right in. Droid App
This app is geared toward those who are looking for a real relationship, rather than a quick hookup or short fling. Every day at noon, you get sent a prospective match based on a specific set of criteria. You can Like them or Pass on. If you like them, you'll be set up with icebreaker questions; if you pass, the app will learn your preferences and try again tomorrow. Droid Apps
IFTTT, which stands for "if this, then that," helps you create custom automations between various online services and devices without any coding experience. The mobile app makes it simple to set up these Applets (previously called recipes) on your own or implement any of the community-created ones. IFTTT is particularly great for controlling smart home devices. Droid Apps
While Pandora may have introduced the world to streaming radio, LiveXLive Powered by Slacker has refined it. You can listen to what Slacker thinks you'll like, or try out one of its human-curated channels and playlists. It also has hyper-specific playlists that appeal to particular tastes and moods, such as Yacht Rock. If you aren't ready to subscribe to Slacker Radio quite yet, you can try out its free version.
Facebook Messenger Kids might seem like it's built for kids, but it's really built for parents. With the app, parents have control over their kids' contact list, and messages can't be deleted — meaning that parents can check in to take a look whenever they want. Of course, there are some pretty sweet features for kids, like kid-appropriate stickers, GIFs, emojis, and so on. Droid Apps
What is most impressive about the ESPN Android app is the sheer number of sports it covers. Everything from American football to Brazilian soccer to Indy 500 is available. For those unmissable games, you can set alerts and follow specific matches as they unfold. It also connects you to videos and news headlines, courtesy of the popular sports cable network. Also, check out ESPN's streaming service, ESPN+. Droid Apps
If an event isn't being organized on Facebook, it's probably being done through Eventbrite. This service makes it easy to manage invites, RSVPs, and even ticket purchasing. Attendees get handy reminders about the events they planned to attend, organizers can see guest lists. We particularly like that Eventbrite can generate QR codes, making event check-in a breeze.
Marking one of Apple's first forays into Android development, Apple Music brings the company's impressive musical catalog to Android. The app is built around Apple's subscription-based streaming service, which dishes up all-you-can-listen music for $9.99 per month, or just $4.99 for eligible students. It suffers a bit on Android for being divorced from the Apple ecosystem, however.
You're terrible at passwords. Don't take it personally! Everyone is terrible at passwords. That's why we all need apps like Dashlane, which generate, save, and replay login credentials wherever they're needed. This smart, cross-platform service makes sure that your passwords, payment information, and other vital information is stored securely but never out of reach.
Developers may find Mobogenie to be a great option for selling their apps. There's an app review process with a snappy 24 hour turnaround, and the revenue split is an attractive 80/20. Mobogenie was originally developed in India and has a large user base there, but also supports multiple languages and could provide inroads into some markets where the Play Store isn't so popular. Droid App


Finnish and Vietnamese public innovation funding agencies have come together to support creation of strong Finnish-Vietnamese partnerships aimed at global business creation. The Finnish Funding Agency for Innovation (Tekes) and the Vietnamese Ministry of Science and Technology (MOST) as the primary funding partners are announcing a Joint Call for companies. IPP2 has been assigned to provide procedural support for the Joint Call. Funding will be available for joint business creation projects with an internationally relevant problem-solving perspective. Funding will be granted to individual company participants of eligible Joint Project Plans according to the funding principles of the financing partners identified by the company applicants.
Previously the deadline for application was on 15.12.2016. However, now Tekes and MOST have agreed the deadline has now been given extension in order to allow this opportunity to reach more people and facilitate the matching between companies.
The new deadline for Joint Project Plan submission is now 5pm, Monday 16 January 2017.
The Joint Call between TEKES, the Finnish Funding Agency for Innovation, and NATIF, the National Technology Innovation Fund, assigned by the Ministry of Science and Technology (MOST) of Vietnam. Vietnam-Finland Innovation Partnership Programme (IPP) facilitates the Tekes-Natif Joint Call for Global Business Creation and provides matchmaking support to bring Vietnamese and Finnish companies together.
Companies already submitted proposals can also review and resubmit the documents with new Deadline.
We encourage all companies submitted EOIs to continue looking for potential partners eligible for the Joint Call and send proposals before extended Deadline on 16 January 2017.


text:
Q: create the PaymentMethodCreateParams manually stripe I am using stripe to collect payments. Instead of using the CardInputWidget I decided to use the built in inputs that stripe has such as stripe.android.view.CardNumberEditText, stripe.android.view.CVCEditText, stripe.android.view.ExpiryDateEditText, and stripe.android.view.PostalCodeEditText. My only issue is that I know I will have to create the PaymentMethodCreateParams manually but I don't know how I will go about it. As of right now I have everything setup for the card Input wiget in my java code. Can someone help me with this and tell/show me how I will go about this. Thanks in advance
//Paymentpage.activity

    <LinearLayout
        android:id="@+id/toolbar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginBottom="1dp"
        android:orientation="vertical"
        android:background="@color/offwhite"
        app:layout_constraintBottom_toTopOf="@+id/linearLayout"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent">

    </LinearLayout>
    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"

        app:layout_constraintBottom_toTopOf="@+id/scrollView3"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        android:theme="@style/Base.CardView"
        >

        <!--
        <com.stripe.android.view.CardMultilineWidget
            android:id="@+id/cardInputWidget"
            android:layout_width="match_parent"
            android:theme="@style/StripeDefaultTheme"
            android:layout_height="160dp"
            android:layout_marginLeft="15dp"
            android:layout_marginRight="15dp"

            -->

        <com.stripe.android.view.CardNumberEditText
            android:layout_width="match_parent"
            android:hint="Card Number"
            android:layout_height="wrap_content"/>

        <com.stripe.android.view.ExpiryDateEditText
            android:layout_width="match_parent"
            android:hint="Expiration date"
            android:layout_height="wrap_content"/>

        <com.stripe.android.view.CvcEditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"/>

        <com.stripe.android.view.PostalCodeEditText
            android:layout_width="match_parent"
            android:hint="Postal code"
            android:layout_height="wrap_content"/>

        <Button
            android:id="@+id/payButton"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginTop="20dp"
            android:layout_marginLeft="10dp"
            android:layout_marginRight="10dp"
            android:background="@color/faux_dukes_shade2"
            android:text="Pay"
            android:textColor="@color/white"
            app:layout_constraintEnd_toEndOf="@+id/cardInputWidget"
            app:layout_constraintStart_toStartOf="@+id/cardInputWidget"
            app:layout_constraintTop_toBottomOf="@+id/cardInputWidget" />

    </LinearLayout>

//Paymentpage.java

 private void startCheckout() {

        //amount will calculate from .00 make sure multiply by 100
        //double amount=Double.parseDouble(mAmount.getText().toString())*1;

        // Create a PaymentIntent by calling the sample server's /create-payment-intent endpoint.
        MediaType mediaType = MediaType.get("application/json; charset=utf-8");

/*
        String json = "{"
                + "\"currency\":\"usd\","
                + "\"items\":["
                + "{\"id\":\"photo_subscription\"}"
                + "]"
                + "}";

 */

        Intent intent = getIntent();
        final String t = intent.getStringExtra("days");

        int in = Integer.valueOf(t);

        String email = FirebaseAuth.getInstance().getCurrentUser().getEmail();

        double amount=in*100;
        Map<String,Object> payMap=new HashMap<>();
        Map<String,Object> itemMap=new HashMap<>();
        List<Map<String,Object>> itemList =new ArrayList<>();
        payMap.put("currency","usd");
        payMap.put("receipt_email",email.toString());
        itemMap.put("id","photo_subscription");
        itemMap.put("amount",amount);
        itemList.add(itemMap);
        payMap.put("items",itemList);
        String json = new Gson().toJson(payMap);

        RequestBody body = RequestBody.create(mediaType,json);
        Request request = new Request.Builder()
                .url(BACKEND_URL + "create-payment-intent")
                .post(body)
                .build();
        httpClient.newCall(request)
                .enqueue(new PayCallback(this));

        // Hook up the pay button to the card widget and stripe instance
        //Button payButton = findViewById(R.id.payButton);
        payButton.setOnClickListener((View view) -> {
            PaymentMethodCreateParams params = cardInputWidget.getPaymentMethodCreateParams();
            if (params != null) {
                Map<String, String> extraParams = new HashMap<>();
                extraParams.put("setup_future_usage", "off_session");

                ConfirmPaymentIntentParams confirmParams = ConfirmPaymentIntentParams
                        .createWithPaymentMethodCreateParams(params, paymentIntentClientSecret);
                stripe.confirmPayment(this, confirmParams);
            }
        });
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        // Handle the result of stripe.confirmPayment
        stripe.onPaymentResult(requestCode, data, new PaymentResultCallback(this));
    }

    public void goback(View view) {
        onBackPressed();
    }

    private static final class PayCallback implements Callback {
        @NonNull private final WeakReference<PaymentPageActivity> activityRef;
        PayCallback(@NonNull PaymentPageActivity activity) {
            activityRef = new WeakReference<>(activity);
        }
        @Override
        public void onFailure(@NonNull Call call, @NonNull IOException e) {
            final PaymentPageActivity activity = activityRef.get();
            if (activity == null) {
                return;
            }
            activity.runOnUiThread(() ->
                    Toast.makeText(
                            activity, "Error: " + e.toString(), Toast.LENGTH_LONG
                    ).show()
            );
        }
        @Override
        public void onResponse(@NonNull Call call, @NonNull final Response response)
                throws IOException {
            final PaymentPageActivity activity = activityRef.get();
            if (activity == null) {
                return;
            }
            if (!response.isSuccessful()) {
                activity.runOnUiThread(() ->
                        Toast.makeText(
                                activity, "Error: " + response.toString(), Toast.LENGTH_LONG
                        ).show()
                );
            } else {
                activity.onPaymentSuccess(response);
            }
        }
    }

    private void onPaymentSuccess(@NonNull final Response response) throws IOException {
        Gson gson = new Gson();
        Type type = new TypeToken<Map<String, String>>(){}.getType();
        Map<String, String> responseMap = gson.fromJson(
                Objects.requireNonNull(response.body()).string(),
                type

        );
        paymentIntentClientSecret = responseMap.get("clientSecret");
    }
    private final class PaymentResultCallback
            implements ApiResultCallback<PaymentIntentResult> {
        @NonNull private final WeakReference<PaymentPageActivity> activityRef;
        PaymentResultCallback(@NonNull PaymentPageActivity activity) {
            activityRef = new WeakReference<>(activity);
        }
        @Override
        public void onSuccess(@NonNull PaymentIntentResult result) {
            final PaymentPageActivity activity = activityRef.get();
            if (activity == null) {
                return;
            }
            PaymentIntent paymentIntent = result.getIntent();
            PaymentIntent.Status status = paymentIntent.getStatus();
            if (status == PaymentIntent.Status.Succeeded) {
                // Payment completed successfully
                /*
                Gson gson = new GsonBuilder().setPrettyPrinting().create();
                activity.displayAlert(
                        "Payment completed",
                        gson.toJson(paymentIntent)
                );

                 */

                String uid = FirebaseAuth.getInstance().getCurrentUser().getUid();
                final DatabaseReference rootRef = FirebaseDatabase.getInstance().getReference("Ads");
                final DatabaseReference update = rootRef.child(uid);
                final DatabaseReference rootRef1 = FirebaseDatabase.getInstance().getReference("card_information");
                final DatabaseReference update1 = rootRef1.child(uid);

update1.child("card_number").setValue(cardInputWidget.getCard().component1());
update1.child("cvc").setValue(cardInputWidget.getCard().component2());
update1.child("expiration_month").setValue(cardInputWidget.getCard().component3());
update1.child("expiration_year").setValue(cardInputWidget.getCard().component4());
update1.child("postal_code").setValue(cardInputWidget.getCard().getAddressZip());

                Intent intent = getIntent();

                Bundle extras = intent.getExtras();

                String get_key = extras.getString("id-key");

                update.child(get_key).child("status").setValue("Paid");

                Intent intent2=new Intent(PaymentPageActivity.this,ProfileActivity.class);
                startActivity(intent2);
            } else if (status == PaymentIntent.Status.RequiresPaymentMethod) {
                // Payment failed – allow retrying using a different payment method
                activity.displayAlert(
                        "Payment failed",
                        Objects.requireNonNull(paymentIntent.getLastPaymentError()).getMessage()
                );
            }
        }
        @Override
        public void onError(@NonNull Exception e) {
            final PaymentPageActivity activity = activityRef.get();
            if (activity == null) {
                return;
            }
            // Payment request failed – allow retrying using the same payment method
            activity.displayAlert("Error", e.toString());
        }
    }

    private void displayAlert(@NonNull String title,
                              @Nullable String message) {
        AlertDialog.Builder builder = new AlertDialog.Builder(this)
                .setTitle(title)
                .setMessage(message);
        builder.setPositiveButton("Ok", null);
        builder.create().show();
    }

A: The recommendation is to leverage CardInputWidget or CardMultiline from the Android SDK instead of the broken up components, those are internal components.

A: Yes you can and here is the code:
 CardInputWidget cardInputWidget = new CardInputWidget(this);
            cardInputWidget.setCardNumber("4242424242424242");
            cardInputWidget.setCvcCode("546");
            cardInputWidget.setExpiryDate(5,22);
            cardInputWidget.setPostalCodeRequired(false);

 PaymentMethodCreateParams params = cardInputWidget.getPaymentMethodCreateParams();

and you can customize your layout as you like.

redpajama_set_name: RedPajamaStackExchange


text:
Q: How do I create a second new pull request from the same branch? I created a pull request, but I was working on the wrong code. So now I want to just create a brand new pull request, starting over so to speak.
I closed the erroneous PR, but do I just go ahead make a new change to the file and commit and push again?

A:
I closed the erroneous PR, but do I just go ahead make a new change to the file and commit and push again?

Generally, yes.  But, as you've seen in comments, there are some complications.
Long: everything you need to know about GitHub PRs
There are several things to understand here.  These come under two general topics:

*

*Git doesn't care about branches.  Git only cares about commits.

*Git does not have Pull Requests.  PRs are an add-on, provided by various web hosting sites, becaues they're useful in terms of making certain operations easy ("one click" web thingies for instance).  As a result, the specific details for updating or replacing a pull request vary somewhat between different hosting sites.

Still, the fact that Git itself only really cares about commits has a certain leak-over effect into these per-hosting-site PR mechanisms.  So the two topics intertwine.
How Git uses branch names to find commits
Let's start with the Git command line.  We run git log or git log --oneline, or maybe git log --all --decorate --oneline --graph ("Git Log with A. D.O.G."; see Pretty Git branch graphs).  Git spills out stuff like the following:
* 670b81a890 (HEAD -> master, origin/next, origin/master, origin/HEAD) The second batch
*   98f3f03bcb Merge branch 'fc/doc-build-cleanup'
|\
| * 7ba3016729 doc: avoid using rm directly
| * db10fc6c09 doc: simplify Makefile using .DELETE_ON_ERROR
| * 471e7b2cf6 doc: remove unnecessary rm instances
| * 56da21392b doc: improve asciidoc dependencies
| * 12d078ed2b doc: refactor common asciidoc dependencies
* |   2019256717 Merge branch 'ab/test-lib-updates'
|\ \
| * | f0d4d398e2 test-lib: split up and deprecate test_create_repo()

Each of these stars, along with its connecting lines, represents one commit.  Each commit itself is numbered: that big ugly hash ID, here trimmed to a mere 10 characters—each one is 40 characters long—is a unique number that means that commit, and only ever that particular commit.  (These particular commits are in a clone of the Git repository for Git.)
Each commit, which Git finds by its unique hash ID, stores two things:

*

*A commit stores some metadata, including the name and email address of its author, for instance.  The metadata tell us who made the commit, when, and—at least if the author is conscientious—why they made that particular commit.  But it also stores the hash ID of some earlier commit, or commits.

*Meanwhile, each commit also stores a full snapshot of every file.  That's where Git gets the files that it will put into your working tree, if and when you select that commit to be extracted.
By comparing any two snapshots—often, two adjacent ones such as 7ba3016729 and db10fc6c09 for instance—Git can tell you which files changed between those two snapshots, and show you the exact changed lines.  But to do this, Git has to find the hash IDs of the two commits.
You can give these to Git directly yourself:
git diff db10fc6c09 7ba3016729

for instance will have Git extract, into a temporary (in-memory) area, these two commits, and compare their snapshots.  The result is that we see that Documentation/Makefile changed.  Or, we can give Git—or perhaps GitHub—the full hash ID of the later of this particular pair of commits, and Git will automatically find the parent for us and compare the two commits (try the GitHub link here, and note that it has embedded in it just the later commit hash ID).
Git finds an earlier commit's hash ID using the metadata in the later commit.  By giving Git—or GitHub—the full raw hash ID 7ba30167291eb89f2e587b7cabfa4e7555de4ed5, Git can start at that commit and work backwards.  The commit's parent, db10fc6c09f1f74c4d0a9294ecbb68d390f54f15, is a commit too, so it has metadata, which gives yet another parent hash ID.  That is yet another commit, so it has metadata, and so on.
Using this metadata, Git can work backwards through the history in a repository.  The commits are the history, via the snapshots and metadata.  But there's one big hitch: where do we get the hash ID of the last commit in some string of commits?  The answer is, typically, from a branch name like master.
The very first line of the git log output I quoted above begins with:
* 670b81a890 (HEAD -> master, origin/next, origin/master, origin/HEAD)

The stuff in the parentheses here are what Git calls the decorations, from git log --decorate.  This --decorate flag is the default now and has been for quite some time, but if you have an ancient version of Git, you may still have to use an explicit --decorate.  What it does is have Git look at all your branch names, all your remote-tracking names, and all your tag names and other such names.  Each of these names stores one hash ID.  In my particular case, three of my Git repository's names—master, origin/master, and origin/next—all store hash ID 670b81a890388c60b7032a4f5b879f2ece8c4558.
When I run git log --decorate --oneline --graph and don't tell Git where to start the log operation, what Git does is this:

*

*Look up the name HEAD.  This particular name contains another branch name:
$ cat .git/HEAD
ref: refs/heads/master

*As a result, look up the branch name master (full name refs/heads/master).  This contains 670b81a890388c60b7032a4f5b879f2ece8c4558: the hash ID of the first commit to be printed.
So that's where git log starts.  It uses hash ID 670b81a890388c60b7032a4f5b879f2ece8c4558 to find a commit, specifically this one.  That commit has one parent, namely 98f3f03bcbf4e0eda498f0a0c01d9bd90de9e106.  That commit is a merge commit, with two parents instead of the usual one; this makes git log's job harder, but what it does is to go on and display both of those commits (eventually), and their parents, and so on.
In other words, Git used the branch name—master, in my case—to find the last commit in the branch.  Then it used that last commit to find the second-to-last commit.  Then it used that second-to-last commit to find yet more commits, from which it found still more commits, and so on.  If I didn't stop it, git log --decorate --oneline --graph would go on to list 63272 commits (at the moment).
Let's reduce all of the above to a simple drawing
The actual hash IDs of commits are big, ugly, and random-looking.  To make a simple drawing, let's replace the hash IDs with single uppercase letters.  This wouldn't work in a real repository because we would run out of letters way too fast, but it's nice for a drawing:
...--F--G--H  <-- master (HEAD)
         \
          I--J   <-- feature

Here, we're on our master branch.  The name master holds the hash ID of the latest master commit.  That's commit H.  Commit H points backwards to earlier commit G, which points backwards to another still-earlier commit F.
If we run git checkout feature or git switch feature, we get this:
...--F--G--H  <-- master
         \
          I--J   <-- feature (HEAD)

The name feature holds the hash ID of commit J, which is the latest feature commit.  Commit J points backwards to earlier commit I, which points backwards to earlier commit G.
Note that commit G, and all earlier commits, are on both branches.  This might be clearer if we draw the commits as:
          H   <-- master
         /
...--F--G
         \
          I--J   <-- feature

It's important to realize that these are the same drawings, even if they look a bit different.  The commits that are "on" some branch are those we can get to by starting from the most recent commit, found by using the branch name, and working backwards.
When we git checkout or git switch to a branch and make a new commit, the new commit automatically extends the branch, like this:
          H--K   <-- master (HEAD)
         /
...--F--G
         \
          I--J   <-- feature

Here, we made a new commit on master, creating commit K.  New commit K points back to existing commit H.
Sending commits from one Git repository to another
When we work with Git, we're working with a distributed system.  Each clone of some repository has all the commits—or more precisely, all the commits it has.  In particular, if we clone some repository:
git clone ssh://git@github.com/path/to/repo.git

and then someone adds new commits to the GitHub repository, we don't have those commits yet.  Or, if we add new commits to our repository, the GitHub repository doesn't have our new commits yet.
To fix this, we need to be able to get commits from some other Git repository—such as the one over on GitHub—or send commits to some other Git repository (the GitHub one, again).  This is where git fetch and git push come in.
Without going into all the gory details (there are many), what these two commands do are:

*

*have one Git repository call up another one;

*pick the caller as sender and the callee as receiver (git push), or the caller as receiver and the callee as sender (git fetch); and

*figure out which commits the sender should send and the receiver should add to their collection.

Git does this by the commit hash IDs.  The hash IDs are unique: no two different commits ever use the same ID, and if two commits have the same ID, they are the same commit.  In a sense, the ID is the commit.  This is why commits must not change, and Git uses an internal consistency check to make sure that commits never do change.  So whoever is the sender just says: I have commit ________ (fill in the blank with a hash ID).  Whoever is the receiver replies with Oh I don't have that, send it or No thanks, I have that already.  If the receiver needs the commit—i.e., does not have it—the sender is obligated to offer its parent commit(s) as well, and the receiver looks to see if it has those commits too, and replies as before.
In this way, the sender sends, to the receiver, all the commits that the sender has, that the receiver lacks, that the receiver will need.  (The sender can choose which commits to offer at all, as is the case during git push, or just list out all of its branch and other names and the hash IDs, as the usual case during git fetch.)  The receiver takes the new-to-it commits and stores them in its big database of all commits and other supporting objects.1
Having done all this, though, there's now a problem: Git finds commits by using names, such as branch names.  If the receiving Git has new-to-it commits, it almost certainly needs to update some name or names.
Here, git fetch and git push work differently:

*

*With git fetch, the receiver normally updates remote-tracking names, such as origin/master and origin/next.  These are names that your own local Git dedicates, just for commits obtained from the Git you're calling origin.  These are not branch names, not in your own Git repository anyway.  These are commits that your Git saw that their Git found by their branch names.  They are using their master to find some commit, so your Git sets your origin/master to find that same commit.
If you want, you can, at this point, update your own master to find the same commit.  (I do this with this particular Git repository for Git myself—this is not the one I generally work in, it's mostly a mirror I update a bit lazily.)  That's not part of git fetch though: that's a second step.

*With git push, though, the sender usually tells the receiver: Please, if it's OK, update one of your branch names to remember this particular commit hash ID.  That is, you, on your laptop perhaps, add new commits to your own local repository, using some branch name.  Then, using that same branch name, you have your Git send your new commits to your GitHub repository, and then ask your GitHub repository to set this same branch name to find the same commit.
At this point, we need to introduce the concept of fast-forwarding and forced updates.  A typical git push ends with a polite request: Please, if it's OK, update your branch name _______ to hold hash ID _______ (fill in both blanks).  But a forced git push ends with a command: Update your branch name _______ to hold hash ID _______!

1There's also a vetting process, where the receiver can first inspect the commits and other data before deciding whether to accept them.  We'll ignore this complication here.

Fast-forward operations
The polite request is the same as the forced-push command, but says if it's OK.  What makes it OK?  Let's go back to our graph drawings.
Suppose that we have, in our repository, these commits:
...--F--G--H   <-- master (HEAD)

Suppose that the GitHub copy of this same repository has the same set of commits, and the same name, master, selecting commit H.
We make one new commit I that points back to existing commit H, so that it adds on to the branch:
...--F--G--H--I   <-- master (HEAD)

If we now run git push origin master, we'll have our Git call up their Git and send them new commit I (it's new: we just made it, they can't possibly have it yet).  Then we'll ask them to set their master to select commit I.
If they do that, their master will end with commit I, whose parent is H.  They still find all the same commits they found before; they've just added some on to the end.
But suppose that, instead of making a new commit I that points back to H, we sneakily, somehow,2 remove commit H from our own master:
          H   [abandoned]
         /
...--F--G   <-- master (HEAD)

Then we make our own new commit I to be used instead of commit H:
          H   [abandoned]
         /
...--F--G--I   <-- master (HEAD)

If we now send commit I to our GitHub copy, and ask GitHub to set our GitHub repo's master to point to commit I, they will say no!  The reason they'll say no is that I doesn't just add on to the existing commits.  If they switch their master to point to commit I, they'll lose commit H entirely.
There are two ways we can convince them to change their master to point to I anyway.  One way is to use the --force flag.  That changes the Please, if it's OK polite request into the forceful command.  GitHub will probably obey this command, as long as we own the repository.3
The other trick we can use is to delete the branch name entirely, or, if there's some administrative way to do this,4 to rename the branch name, so that the name master is freed up to use to point to commit I.  Then, having gotten the old name master out of the way, we can create a new master, which we can point to whatever commit we want.
Since branch names normally move—to add more commits to the end of the branch—Git has a word for this, or maybe two words: fast-forward.  When new commits just add on to a branch, that branch-name motion is a fast-forward operation.  When the branch name can't just be "slid forward", though—as when we have master back up from H to G before moving forward to I—that's a non-fast-forward operation.

2We probably did this with git reset --hard HEAD^ or similar, but we might use git commit --amend to do it all at once.
3Using GitHub's notion of a protected branch, we can make GitHub refuse to update our own commands.  If we do that, we will have to go in to GitHub using their web administration interface and de-protect the branch name master long enough for us to get rid of bad commit H.  We can re-protect the name afterwards, or just give ourselves administrative privileges to override the protection, or whatever we want to do, but the point here is that we have to use GitHub's web interface to override the protections we set with GitHub's web interface.
None of this is a Git operation.  Git doesn't have the notion of protected branches at all.  This is all stuff that GitHub added on.  What this means in practical terms is that if we decide to move everything to Bitbucket or GitLab, we'll have to change how we administer this, assuming that Bitbucket and GitLab even have the same add-on ideas.
4Note that to rename a branch in our own repository on our laptop, we use the command-line git branch -m command.  There's no git push option to rename a branch; there's just the one to delete it.  So git push --delete can delete the GitHub branch, provided it's not protected from deletion.  But renaming would require a web interface page.

Summary so far
In general, what you do is:

*

*clone a repository (perhaps before or after using GitHub's fork, which we'll get to in a moment) to your local machine (e.g., laptop);

*create new branch names in that local repository, and use those to keep track of new commits that you add;

*then run git push to send those new commits to a GitHub repository where you have permission to create or update branch names.

The git push step will succeed provided that:

*

*you have permission, and

*the operation is a fast-forward (merely adds commits) or creates a new branch name.

If you get ! rejected (non-fast-forward), it means that you've chosen a git push operation that would first remove some commit from the existing branch name over on GitHub (then maybe, or maybe not, add new commits too).
Assuming you're using git push to send new commits to a GitHub repository that you own, you can use git push --force if you wish to override a non-fast-forward error.  This tells the Git over at GitHub that, yes, you really did intend to drop the old commits in favor of the new ones.
You'll generally need this after a git rebase, because rebase works by copying some old-and-now-bad commits to new-and-improved commits.  No existing commit can ever be changed, so if some existing commit has a problem, and you want to fix that problem, you need to toss out the old commit in favor of the new-and-improved one.  That means you're telling your Git to discard some old commit—but if you've sent that old commit to GitHub, they won't want to discard it either.  Your Git knows that the rebase is a replace old and lousy commits with these new improved ones operation, but their Git just sees toss out some old commits, here's some new ones without the due to a rebase part.
Clones and forks
In some cases—such as when you are an employee of some company—you may have direct access to a GitHub repository.  It may have protected branches (you can't push directly to master for instance), but you can create your own branch names in that GitHub repository, and use force-push with those branch names if needed.  In this case, the picture stays relatively simple.  There are just two repositories you'll worry about:

*

*There's the corporate one over on GitHub.  You might need to be just a bit more careful with this one, since breaking it gets everyone mad at you.  Just be super-careful with force pushes, making sure that you only do this with your branches.

*And, there's your private clone, on your computer (e.g., a laptop).  If you wreck this somehow, you can just re-clone the corporate GitHub repository, so you don't have to be quite so careful (though of course losing work is no fun).
In this setup, when you go to make a PR, you just git push to your own branch, then open the PR.  If you need to update your PR, you can either git push or git push --force to your own branch: GitHub automatically updates the PR.  The set of commits in the pull request is simply the set of commits in your GitHub branch that are not in the "base branch" (another branch in the same repository).
But you might not have direct access to the GitHub repository.  There's an alternative method, using GitHub's "fork" operation.  Some companies set things up this way for safety reasons, and many open-source projects use this same technique.  In this kind of setup, things get a bit more complicated, because now there are three repositories involved.
It's time to take a small detour, and introduce the difference between a clone and a fork.  Let's look first at a regular clone.
A clone copies all the commits and none of the branches
Let's start with:
git clone ssh://git@github.com/path/to/repo.git

You run this command on your laptop, having set up your ssh key access to GitHub.  Your Git creates a new, totally-empty repository: it has no commits and no branches.  Your Git then adds the name origin as a remote, so that the URL is saved, and connects to their Git at the URL.  Their Git lists out all their branch and tag and other names and the corresponding commit hash IDs.  Your Git says that you want everything, because you have no commits at all.  They package up and send over everything, and your Git creates remote-tracking names for each of their branch names.
The result of all of this is that you now have all the commits, and no branches.  Instead of branches, you have remote-tracking names to remember the last commit in each of their branches.
Finally, before returning control to the command line so that you can begin working, your Git creates one branch in the new repository, and does a git checkout of that one name.  The branch name that your Git creates comes from your -b option, to your git clone command.  If you don't give a -b option, your Git asks their Git, over at origin, which name they recommend, and uses that name.  Your Git creates your branch of that name based on the commit found by their branch of that name, which is now in your origin/whatever remote-tracking name.
The final end result is that in your new clone, you have all of their commits and one branch.  The one branch you have here is yours, although the name points to the same commit as their branch of your choice.  You can now begin adding commits to your branch, or create new branch names.
A fork copies both commits and branch names
When you use GitHub's fork button, GitHub makes a clone, but they don't do it the standard way, that gets remote-tracking names instead of branch names.  Since this clone isn't on your computer, they instead copy all the branch names from the original commit.  These are now separate names, but your GitHub fork has all the same branch names, pointing to the same commits, as the repository you just forked.
At least, it does now.  This is where the problems start.  Now that you have your own fork, any changes that update their branch names don't update your fork.
What this means for you is that you should now clone your fork, and, as soon as this git clone process finishes, you should add a remote to your laptop clone.  This remote needs a name and a URL.  You already have a remote named origin; the URL for this remote is your GitHub fork.  But you need two remotes.
The usual second-remote-name is upstream.  I'm not a huge fan of this name but don't have my own recommendation, so if you wish to use upstream, you'll run:
git remote add upstream ssh://git@github.com/path/to/original.git

This path/to/original.git part is the URL that you need to give to GitHub to access the repository you forked.
Once you've done that, you will need to run:
git fetch upstream

to obtain any new commits they have that you don't—there probably aren't any, unless they've added new commits since you pushed the fork button—and to create, in your laptop Git repository, remote-tracking names for each of their branches.
Let's say that the upstream has branches named main, feature/short, and feature/tall.  Your GitHub fork will have branches named main, feature/short, and feature/tall.  Your clone on your laptop will have remote-tracking names: origin/main, origin/feature/short, and origin/feature/tall.
You may or may not want to keep those branch names in your GitHub fork.  You may or may not want to keep all those remote-tracking names in your laptop clone.  But you probably do want to add, to your laptop clone, remote-tracking names upstream/main, upstream/feature/short, and upstream/feature/tall.  That's what your git fetch upstream will do.
Now, as new commits are added to upstream's main or feature/short or whatever, you can run git fetch upstream to get these new commits onto your laptop.  You can then run git push origin upstream/main:main to send those new commits to your GitHub fork and update your GitHub fork's main, if you want to do that.
Wait, what's this new git push?
I've just introduced a new git push syntax here, so let's revisit git push:

*

*We run git push origin somebranch to send our new commits from our branch somebranch to our GitHub fork and create-or-update the branch name somebranch over on the GitHub fork.

*This uses what Git calls a refspec.  The name somebranch at the end here is short for somebranch:somebranch.  The two names, on the left and right side, have two different purposes:

*

*The name on the left, somebranch, is for our Git.  Our Git looks up the commit hash ID using this name.  That's how it knows which commit(s) to send.

*The name on the right, somebranch, is for the remote (origin, the fork).  That's the name we're going to ask (regular push) or command (force-push) them to create-or-update.
What we'll do, now that we have upstream/*, is transfer new commits from the original repository on GitHub to our fork on GitHub.  To do that, we bring those new commits into our laptop Git repository, updating upstream/main, upstream/feature/short, and and so on.
Having gotten those new commits, we want to send them to origin, so we can git push origin upstream/whatever:whatever.  The name on the left of the colon—upstream/main for instance—locates the commit in our repository that we just got from upstream.  The name on the right of the colon is the branch name we want GitHub to update in our fork.
Making a PR with a fork
Now that we have this fork, we use one other special feature of a GitHub fork.  With a GitHub fork, we can make a pull request to the original repository we forked.  To do that, we:

*

*create or update a branch in our GitHub fork (with git push from our laptop);

*use the pull request button on the GitHub page to make the new PR.

Any time we git push to our GitHub fork, GitHub will automatically update the PR.  So, if we need to revise our PR, we don't have to close or delete it first: we just have to push—or maybe force-push—to our GitHub branch.  Of course, first we'll need the right set of commits, which often means we need to git fetch upstream and then maybe rebase using upstream/feature/short or upstream/main or whatever as the new base.  If this creates a non-fast-forward situation, we will have to use git push --force or equivalent to update our GitHub fork afterward.


text:
Blood Bath
Rados Novakovic/Michael Roy/Jack Hill and Stephanie Rothman
1963/1965/1966/1966 (May 30, 2016)
American International Pictures/Orion Pictures/MGM (Arrow Video)
Film/Program Grade: See Below
Video Grade: See Below
Audio Grade: See Below
Extras Grade: B+
Overall Grade: B+
Blood Bath was released in 1966 by American International Pictures on a double bill with Queen of Blood. The movie's convoluted production history makes it one of the most fascinating films of any era. Over the course of a decade, what began as a generic spy thriller morphed itself into a bit of a mindless vampire horror movie with sequences that damn near rival Ed Wood in terms of execution. Along the way, it found itself being made into no less than four different films and released at different times, all thanks to the combined efforts of Roger Corman and his various cast and crew at the time.
In the early 1960's, Corman was looking to invest in movies from other countries, chiefly Russia. While he was busy doing that and personally directing other projects, he handed off duties to make a film in Yugoslavia to various cast and crew from their previous film Dementia 13. The resulting project, Operation Titian (known as Operacija Ticijan in Europe), featured a plot involving a man killing another man for a priceless painting, only to find that it has been replaced with a copy and that somebody has double-crossed him. Meanwhile, the police are looking for whomever is bumping off people related to the painting one by one. Later re-edited into Portrait in Terror, it tells pretty much the same story, but with different editing choices and a different score. The film was again reworked by Jack Hill into Blood Bath, this time shooting almost a completely new movie to go around various pieces of footage from the original shoot as a bit of a paean to A Bucket of Blood. Most of the new footage involves a painter who is turning into a vampire and murdering young women, albeit while a group of competing surrealist beatniks get in his way. Fledgling director and Corman assistant Stephanie Rothman took over Hill's version before its release, and then later re-edited yet again with newly-shot sequences into Track of the Vampire. Each of the films (outside of Operation Titian) have been available for years in various ways, but this is the first time that all of them have been presented together in one place.
As far as the quality of each film is concerned, I originally found Operation Titian to be a bit of a slog to get through, and not just because it isn't a horror film. The film is actually well-photographed, and it has some very few good editing choices, but it's mostly just a boring movie. It seems to have no forward momentum, as well as very dated and ineffective musical cues. In retrospect, it's still probably the best version of the story compared to what came later. Portrait in Terror is pretty much the same film, but just a bit slimmer with a different beginning and ending, a couple of extended scenes, and a different, more effective score. Still not an overly strong film, but some of the original sequences aided by the new score are a little more successful. Blood Bath is where the movie truly begins to take on a new life. Most of the original footage from both of the previous versions of the movie is now gone, with only pieces of it remaining. Surprisingly, almost all of the new footage was actually shot with actor William Campbell, who had already been in the previous versions. Track of the Vampire takes footage from all of the different versions of the movie, adding in two new sequences that don't really have anything to do with the main plot, but follows the same through line as Blood Bath. A portion of the plot from Portrait in Terror involving Patrick Magee's character has also been added back in, but with overdubs to try and utilize it in a different context.
When you get right down to it, there is no real definitive version of this movie. All of the versions have more cons than pros, and some versions are better than others. I personally feel that Operation Titian and Portrait in Terror are the better versions, overall, and even they aren't all that amazing. They have a firm photographic stamp and style, even though their stories are a bit of a bore at times. But, most people looking in will likely be drawn to the horror versions included in this set, and I can certainly understand that. It was my original draw to it, as well. Yet, after watching them all back to back, it's easy for me to see what is the most effective. It's amazing to think that Roger Corman and the people under him would spend so much time trying to make a better movie out of only one, but since they did, we now have this fascinating behind the scenes look at a set of movies that changed both in story and style over time.
This Region A/B Limited Edition Blu-ray boxed set features all four versions of the film via 2K restorations, aside from Operation Titian, which is a complete reconstruction from the ground up. All of these various versions have been cobbled together from several different sources, including both HD and SD. Operation Titian's presentation is the most rough-looking. All of its black and white levels vary from scene to scene, as does its contrast and brightness. There are some density issues, some crush, multiple scratches and lines running through the frame, and minor instability. It also features the aforementioned use of SD shots, as there are apparently no film prints available to cull them from. Portrait in Terror favors better, but features much of the same quality, minus the SD shots, obviously. Blood Bath has a stronger and more stable look overall, with less density issues, stronger blacks, and better brightness and contrast. It still features some of the aforementioned artifacts, however. Track of the Vampire is mostly identical, outside of the re-added sequences. Considering what Arrow Video had to work with, I think they pulled off an impossible job. We're just lucky that these low budget movies haven't disappeared entirely, or been destroyed. Judging them solely on their looks would do them an injustice, and I for one, applaud Arrow's efforts. All four versions also feature an English mono LPCM soundtrack, as well. The sound in each of the films is decent, but don't expect anything approaching fine quality. There's noticeable hiss most of the time and dialogue is often hampered by distortion, as is the music and sound effects. However, dialogue is always easily understandable. The imperfections stick out more than most mono tracks presented on Blu-ray, but again, having it at all in any salvageable condition is worth the effort. All four versions also have subtitles in English SDH for those who might need them.
OPERATION TITIAN (FILM/VIDEO/AUDIO): C+/C+/C
PORTRAIT IN TERROR (FILM/VIDEO/AUDIO): C/B/C
BLOOD BATH (FILM/VIDEO/AUDIO): C+/B/C
TRACK OF THE VAMPIRE (FILM/VIDEO/AUDIO): C+/B/C
The supplemental materials include the terrific longform visual essay The Trouble with Titian: Revisited, an examination of Blood Bath and its various incarnations by author and "Video Watchdog" extraordinaire Tim Lucas. In all honesty, this video piece is much more interesting and entertaining than any of the films in this set and is worth the price tag alone. Also included is the Bathing in Blood with Sid Haig interview; the Jack Hill on Blood Bath interview; a still gallery; a double-sided fold-out poster with new artwork on one side and the original poster artwork on the other; and a limited edition 40-page insert booklet with essays on the film and its cast by Anthony Nield, Vic Pratt, Cullen Gallagher, and Peter Stanfield. Arrow Video originally announced that a set of outtakes for Track of the Vampire had been located and were to be included as an extra, but it turned out to actually be footage that was meant to be in the final film (as explained by Tim Lucas in the visual essay).
It's been said before and it'll be said again in the future, but Arrow Video is killing it with these amazing releases of absolutely obscure material. Blood Bath and its many other versions are no masterpieces by any stretch of the imagination, but having them all in the same package with the benefit of both hindsight and context makes this set a textbook example of how a film is shaped and formed over the course of a production... or in this case, productions. This is an amazing release, and definitely worth checking out if you're into that sort of thing at all. Highly recommended.
1963, 1965, 1966, AIP, American International Pictures, Arrow Video, Blood Bath, Blu-ray, Blu-ray Disc, boxed set, horror, Jack Hill, MGM, Michael Roy, Operation Titian, Orion Pictures, Portrait in Terror, Rados Novakovic, Region A and B, review, Roger Corman, Sid Haig, spy, Stephanie Rothman, The Digital Bits, thriller, Tim Salmons, Track of the Vampire

redpajama_set_name: RedPajamaCommonCrawl


text:
Q: assigning devices to operations in Tensorflow via attributes Is there a way to assign the device after the operation has been created? so rather than use the with tf.device(u'/gpu:1') for example we could use a op.device = u'/gpu:1' (obviosly this does not work but was wondering if there is something similar)
Note: op is a tensorflow operation where type(op) returns tensorflow.python.framework.ops.Operation
Thank you


We are thrilled to announce, 'FuSIon Fest – The Social Innovation Festival', will be taking place in Northern in Derry and Belfast on 19th and 20th October 2017.
The Festival is a one-day programme that will be repeated in each city and will take place in the Playhouse in Derry-Londonderry and the Crescent Arts Centre in Belfast. Delegates will hear from 3 keynote speakers, participate in a number of breakout sessions and have access to the Social Innovation village featuring practitioners, innovative organisations, and a space to network and learn more about Social Innovation. The Festival will finish on the evening of 20 October with an afterparty and final keynote on the Belfast Barge and complimentary return transport from Derry will be provided for delegates.
Who should attend? Come one, come all - no experience needed! Anyone with a desire to build lasting social change in our society: educators, government departments, communities, entrepreneurs, big businesses, techpreneurs and innovators. Let's get together as one collaborative community to have fun, meet interesting people and explore possibilities.


Maurizio Manzo joins the Grignani Firm in 2009, after working for an important law firm from October 2008 to November 2009.
He obtained a Master's Degree in Law on October 16, 2008, at the University of Milan, discussing the degree thesis in Private Law in the field of Antitrust.
Maurizio deals with judicial and extrajudicial assistance to PMI and has consolidated his experience in the field of company law and financial market law, participating in specialization courses in 2013-2014-2015 at the University of Milan and a Brief Master in Corporate Law and Litigation in 2016.
It is registered in the Register of Lawyers Established in Milan from Decembrer, 15 2016.


Imagine you are a researcher dealing with extremely dangerous things. I mean Manhattan Project level. You obviously want to keep all the documents away from the enemies. How would you go about doing this?
An idea I had was to make the paper out of gun-cotten. If someone tried to forcible take the papers from you, then you just need a lighter and a few seconds to upset their entire plan. The downside, if someone reads your notes while smoking years or research can go up in flames.
The next idea was weaving strands of magnesium into the paper. It is much more stable than gun-cotten and burns so hot there is no reasonable way to put it out. The downside to this is carrying around pure magnesium all day is a bad idea even if it was properly stored.
I think that any cryptographic approach to secrecy is going to be vastly superior to an option where you have to be physically present to set something on fire. If somebody just stole those documents without your notice, the fact that they were super flammable would not be a significant hurdle unless they were combustible in contact with a common substance... e.g. the documents are made of something that must be kept in a vacuum chamber and explodes on contact with air. But I think it's probably just better to use some encryption scheme.
I'm assuming we're not considering digital storage here?
Are you actually committed to your framing narrative and want to talk about security, or do you just want to talk about things that are flammable?
the classic spy trope involves a miniature camera with which the intrepid spy photographs the pages secretly, preferably while suspended from the ceiling.
anything that requires knowledge of the breach won't help against that.
Messages sent to and between spies generally are intended to be destroyed after reading. But you don't need anything fancy to do that. Regular paper is already flammable enough, or you could just crumple it up and drop it into the ocean. Of course, now that messages are sent digitally, none of this really applies anymore, anyway.
An idea I had was to make the paper out of gun-cotten.
If you're set on this approach, "flash paper" made of nitrocellulose (otherwise known as guncotton) is absolutely a thing.
Though I think edible paper would be safer. Crypto isnt always the best solution, for example if you want to draw an impromptu map, or want it to be readily readable. Flammable storage probaly isnt the best for important research though.
Try the reverse! Encode your private data in something like a Rubens tube which, interfered with/taken away from an authorised handler stops being on fire and a bimetal and/or Seebeck detectors no longer prime the wave generator.
Never mind your Flash memory, Entropically Erasable Pulsed Rapid Oxygenation Memory is the way to go!
Eebster the Great wrote: Messages sent to and between spies generally are intended to be destroyed after reading. But you don't need anything fancy to do that. Regular paper is already flammable enough, or you could just crumple it up and drop it into the ocean.
I was thinking more along the lines of the 1979 Iran Hostage Crisis.
doogly wrote: do you just want to talk about things that are flammable?
Yes, but that is true most of the time.
I think "better paper shredders" is a more feasible solution than "light it all on fire." Paper records are already a huge fire hazard when stored in such quantity.
Just as a note too, it is apparently possible to recover at least part of the text from burned pages depending on the type of paper and ink used. Especially if you're doing quite ignition rather than a sustained burn, it's entirely possible that the pages will still be usable. You might be better off using a dissolving paper, which can dissolve quickly in water or acid... so you can just flush your important documents down the toilet or something and they'll be gone forever.
You know those wax tablets the Romans used to use?
Replace wax with plastic explosive.
Sure, if you carefully burn the paper keeping it intact. This is easily solved by stirring the ashes (which also helps burn the parts of the paper that weren't quite exposed to the flame).
LaserGuy wrote: You might be better off using a dissolving paper, which can dissolve quickly in water or acid... so you can just flush your important documents down the toilet or something and they'll be gone forever.
Eebster the Great wrote: Unshredding a mound of paper still sounds like the most agonizing task ever.
If you want to talk agonizing, there are some cases where people of debatable character where able to take pieces of hard-drives from the trash of government offices and extract information from them. They literal went bit by bit through the fragments of drives and ran the results through random programs until something legible came out.
Last edited by jewish_scientist on Wed May 02, 2018 2:24 pm UTC, edited 1 time in total.
LaserGuy wrote: I think that any cryptographic approach to secrecy is going to be vastly superior to an option where you have to be physically present to set something on fire.
It's probably superior against most attacks, but it has a downside: encryption does not destroy information. If a spy runs off with an encrypted disk, they have all the time in the world to break it, and we simply don't know if our current crypto algorithms will survive future mathematical insights or quantum computers.
If you're only interested in maintaining a headstart against the competition, then crypto will delay your spies for long enough. If you intend to keep a secret until the end of humanity, then crypto alone is risky.
p1t1o wrote: Crypto isnt always the best solution, for example if you want to draw an impromptu map, or want it to be readily readable.
Tablet computers with full disk encryption are a thing, including pens for doodling maps. Configure them to shut down when leaving the facility (i.e. when out of reach of the wlan) and you're pretty well protected against physical theft.
Soupspoon wrote: Entropically Erasable Pulsed Rapid Oxygenation Memory is the way to go!
It is sometimes possible to restore information from burnt paper (didn't you watch that one episode of MacGyver where he did it?), but crumbling and mixing the ashes should solve that.
Restoring shredded documents is surprisingly easy. Dump everything on a table, flip each part text-side up, take a picture, let the software handle it. You won't find suitable software for $1.99 on the app store, but it exists.
As others have said, neither crypto nor flammable things will prevent a spy from taking photos or memorizing information. If your information can be read, then it can also be copied.
Indeed, if you happen to have an encrypted tablet with you, thats an option. But for example, right now, I have no secure hardware with me but plenty of destructible matter.
Further, even an encrypted tablet is vulnerable to social engineering attacks and other leftfield approaches.
You can't trick me into giving you the password to a pile of ash. Nor can you make a copy of it, or even gain access without coming into direct physical contact.
It's probably superior against most attacks, but it has a downside: encryption does not destroy information.
Technically, nothing a person does can actually destroy information due to the Laws of Thermodynamics.
Technically, we are all part of the information that is in question. Read Hofstaeder's works about this. They are excellent.
If it has text on both sides, then there might be more difficulty determining common-front vs common-back to the sheet, but once you think you've got a neighbourly match you have twice as much edge-to-edge to compare to verify it.
What you need is paper printed on the obverse with mismatching stripes of text that (carefully aligned to the slices that would be eventually made by the shredder) that carefully parodies the content on the normal side, plus obfuscates all attempts to check mutual alignment so that you're as likely to produce a William S. Burroughs novel as any original or contextually-checkable near-original.
With text on both sides surely all you need to do is take a picture of all the strips one way round, reverse them, take another picture, and it's an equivalent problem to solving a one-sided piece of paper twice as big.
Give or take, although it starts off with something close to (2n)! rather than (n)! at the stsrt, but then gets easier and easier as each successful placement of a strip on the left half of the double-width, or lower half of a double-height, simultaneously places the opposite-side-of-the-strip in a mirror position to the right, or reverse-complimentary position on the upper.
speising wrote: the classic spy trope involves a miniature camera with which the intrepid spy photographs the pages secretly, preferably while suspended from the ceiling.
I suppose it'd be possible to have something that can only be read from close up with a special lens. Perhaps even to the point that you only need to destroy the lens and not the paper itself.
As far as I know, you still cant beat one-time-pads for secure encryption.
jewish_scientist wrote: Technically, nothing a person does can actually destroy information due to the Laws of Thermodynamics.
Being true to the comic, everything following "Technically" is complete nonsense.
p1t1o wrote: As far as I know, you still cant beat one-time-pads for secure encryption.
All asymmetrical cyphers rely on the unproven assumption that one-way functions exist. You can avoid that reliance by using symmetric cyphers like OTPs, but they have the distinct downside of being symmetric.
Also, these primitives are about communication. Document or disk encryption typically uses entirely different primitives, and usually the secret key is a passphrase. The LUKS disk format is documented, if you feel like diving in.
Flash paper (nitrocellulose) burns cleanly without leaving behind traces of the text. I've seen it recommended for key storage that can be quickly destroyed if your door is busted down by government agents, to be used in combination with a hand cipher like Solitaire.
Flash paper is basically the commercial solution to this, yes.
That said, a white phosphorous grenade will also do the job just fine, with entirely normal paper. Presuming you are storing whatever it is securely, you would be well served to keep the destructive device separate from the presumably important documents. Accidental destruction would probably be a problem. If you are particularly concerned about reconstruction from the burned paper, following up the WP with a standard frag grenade ought to work just fine to disperse the burned remnants. That ought to handle quite a significant amount of documents.
I advise you not be anywhere close to the items you intend to destroy if using this method.
Tyndmyr wrote: Flash paper is basically the commercial solution to this, yes.
That said, a white phosphorous grenade will also do the job just fine, with entirely normal paper.
If you really want to be secure, keep your special papers mixed in with papers of random stuff (say, a copy of war and peace). Then, use the frag grenade to incinerate and thoroughly mix your papers up with the random, unimportant stuff.
You could spell out your information will 2mm ballbearings on a huge flat floor, like a warehouse.
Men in Black come calling? Just tilt the floor by a degree or two.
Spell out your information with dominos.
MiB come around? You know what to do.
Or you could use an atomic force microscope to inscribe your information with atoms onto a large sheet of...I dunno...graphite? At a random location on the sheet.
It is secure by virtue of being unable to find the text on the sheet within the age of the universe.
p1t1o wrote: Or you could use an atomic force microscope to inscribe your information with atoms onto a large sheet of...I dunno...graphite? At a random location on the sheet.
If you can easily remember the location, it can be brute forced (the location is just a key, and if it's memorable then it's not random).
p1t1o wrote: You could spell out your information will 2mm ballbearings on a huge flat floor, like a warehouse.
a suspicious pattern of dust-free spots emerges on the floor.
You really need to turn that warehouse upside-down and shake it a couple of times.
Thesh wrote: if it's memorable then it's not random.
This is perhaps the wrongest thing I've read all day, and I read (okay skimmed) CU's posts about economics in the Other News thread.
If I remember that the last time I rolled a die it was a 3, does that roll become retroactively nonrandom? How about if I remember the last 50 rolls?
The actual (theoretical) problem is the fact that the location of a particular atom on a 1m^2 sheet of graphene has only about 64 bits of entropy(based on carbon-bond lengths and assuming it's a square arrangement rather than hexagonal--the different shape isn't going to change the result by more than one or two bits in any case).
No, a dice roll is not random because if you know the initial state and the forces acted on it, then it is completely predictable.
Okay, fine, it was a poor choice of wording.
The entire point of correct horse battery staple is that memorable is not synonymous with weak when it comes to passwords.
Going from a passphrase to a location is a lot easier than going from a location to a passphrase. The point I intended (but apparently forgot) to make when I started writing that was that it just turns a problem of storing information into a problem of storing the key. If you just pick a random location, you aren't likely to be able to memorize it and are then going to have to store it somewhere.
A) Dust-bomb (talcum powder would do it!) set to disperse across the floor almost immediately after the floor-tilt. Even if the dust doesn't exactly match, without significant dust (since the last time you used a low-power air puffer to send dust into extraction filters without moving the balls) archaeologically digging into new dust to discover the 'post holes' in the old dust is going to be an excrutiating task for a 'data-recovery' specialist.
B) With both the ball-bearings and the STM/grqphite-sheet 'solutions', employ obfuscating sort-of-steganography. The key pattern, you remember from an initial arbitrary choice, is centred upon 1/10th of the way from one edge and 3/10ths of the way from the other edge of the floor/sheet and is the array of bearings/atoms (or lack) that is, say, 45 times 35 in size. Outside this footprint, you ensure that cryptologically indistinct (but not footprint-repeating in any meaningful way) distributions of bearings/atoms are laid down. Without the location/size knowledge (which you can even crib in another easier to remember locale, like encoded in the pattern of the third row away from the left edge) all the intensive scanning of what remains of your 'destroyed' data (or even the intact record, if you've done enough to make the key Key location indistinct) is just going to add to the failed runs the decrypt-team is going to have to rule out.
As far as I know, such a program has only ever been created once, for a competition, and though it was somewhat effective, it only worked for shreds in ideal conditions (single sided, no marks or stains, no pieces missing, etc.), and it still requires humans to operate it and effectively build the page up from scratch but with the computer offering possible matches along the way. I have no doubt that a better program could be invented, but shredding may be superior to printing all your documents on explosives.
The Fraunhofer Institute has something like this for reconstructing documents from the Stasi. It wouldn't surprise me if some of the major intelligence agencies have an in-house version of this as well.
Thesh wrote: Flash paper (nitrocellulose) burns cleanly without leaving behind traces of the text. I've seen it recommended for key storage that can be quickly destroyed if your door is busted down by government agents, to be used in combination with a hand cipher like Solitaire.
Flash paper is the same things is gun cotton, which is disqualified in the OP as being too easy to accidentally set off.
pogrmman wrote: If you really want to be secure, keep your special papers mixed in with papers of random stuff (say, a copy of war and peace).


treatment by the Berlusconi government.
sturdy enough to withstand the tremors.
riven by dangerous structural flaws.
the death of a protester.
distraction as a humanitarian effort.
what attitudes would be among the survivors.
L'Aquila were recounted with bitterness.
in response to the layoffs.


text:
Q: Javascript recursions. Why the following code works with .unshift() instead of .push()? My brain believes that I should use .push() instead of .unshift() but freeCodeCamp and my console tell that this is the right way of doing it. I just don't understand how come my numbers go from 10 to 20 using .unshift(), and 20 to 10 using .push();
The way I read the code:
if startNum is bigger than endNum return an empty array. Otherwise, create a variable called arr and assign to it the current startNum increased by 1 each time the code runs and return it into the array.
What am I doing wrong?
function rangeOfNumbers(startNum, endNum) {
  if (startNum > endNum) {
    return [];
  } else {
    const arr = rangeOfNumbers(startNum + 1, endNum);
    arr.unshift(startNum);
    return arr;
  }
}

console.log(rangeOfNumbers(10, 20));

The console: (11) [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

A: unshift inserts an element into the beginning of the array.
Since you're iterating from the startNum to the endNum, consider the next to last recursive call:
const arr = rangeOfNumbers(startNum + 1, endNum);
arr.unshift(startNum);
return arr;

where startNum is 19 and endNum is 20. The recursive call returns an array with one element: [20]. Then you need to insert the 19 element in the proper position.
To do this, you'll need to insert the 19 at the beginning, to get:
[19, 20]

So, insert 19 at the beginning with unshift.
If you used push instead, from the original [20], you'd get:
[20, 19] // 19 added to end

and then
[20, 19, 18] // 18 added to end

and so on, which isn't in the right order.
You could use push if you inserted elements before the recursive call.

function rangeOfNumbers(startNum, endNum, arr = []) {
  arr.push(startNum);
  if (startNum < endNum) {
    rangeOfNumbers(startNum + 1, endNum, arr);
  }
  return arr;
}

console.log(rangeOfNumbers(10, 20));

A: One way to think of it is to imagine that the recursive call already worked properly.  So rangeOfNumbers(11, 20) would yield [11, 12, 13, 14, 15, 16, 17, 18, 19, 20].  And so  const arr = rangeOfNumbers(startNum + 1, endNum) means that arr is [11, 12, 13, 14, 15, 16, 17, 18, 19, 20].  Now you have startNum and arr and need to combine them.  push would add startNum to the end.  unshift properly adds it to the beginning.
But while we're here, I'd like to suggest a more elegant way to express that same algorithm:
const rangeOfNumbers = (start, end) =>
  start > end
    ? []
    : [start, ... rangeOfNumbers (start + 1, end)]

Instead of if-else statements we have a single conditional expression.  And we don't mutate a variable like arr in the process.  I think it also more cleanly expresses the algorithm.  Of course tastes may vary, and, if you're just learning JS, this may involve syntax you haven't seen yet.  But if you do understand it, you might agree with me about its elegance.


The School Council and Miss Wilson delved into the history books in the last few weeks so they could share some highlights of our history at our whole school assembly today.
Spreydon School celebrated 144 years with a cake and a wristband for all children so they can proudly wear the Spirit of Spreydon Values everyday. The School also showed their true colours by coming dressed in an Olympic theme. It may have been a coincidence that New Zealand won a medal during our passionate singing of the Nation Anthem. Thank you to the PTA for organising the mufit day.


text:
BVB-Aktie > IR News > Corporate News > Into the future with two shirt sponsors
Into the future with two shirt sponsors
CVTKNFSKCVEAEJQVBCBWIWFU
DGAP-News: Borussia Dortmund GmbH & Co. KGaA / Key word(s): Contract Into the future with two shirt sponsors
20.02.2020 / 08:00 The issuer is solely responsible for the content of this announcement.
Evonik aligns partnership with BVB to international target groups.
1 & 1 takes on the role of shirt sponsor in the Bundesliga.
Bundesliga soccer team Borussia Dortmund will have two different shirt main sponsors from season 2020/2021 (starting: July 1st, 2020) onwards and for the first time in its history: the specialty chemicals group Evonik and the telecommunications company 1 & 1.
Evonik opens the way for the innovative model by focusing the long-term partnership with BVB on international target groups. As a result, 1 & 1 takes over as shirt sponsor in the attractive environment of the Bundesliga. Evonik remains as hitherto shirt main sponsor in the international competitions (for example UEFA Champions League) and in the DFB-Cup.
BVB increases sponsoring revenues with this new structure from season 2020/2021 onwards.
The contracts with the two shirt main sponsors each have a term until June 30, 2025.
Dortmund, February 20th, 2020
20.02.2020 Dissemination of a Corporate News, transmitted by DGAP - a service of EQS Group AG. The issuer is solely responsible for the content of this announcement.
The DGAP Distribution Services include Regulatory Announcements, Financial/Corporate News and Press Releases. Archive at www.dgap.de


The buying journey evolution is social, expertise-driven, and complicated. Unfortunately, most companies are struggling to keep up with this new model. Here's a likely reason why: The customer service area, traditionally the most knowledgeable about typical questions, is relegated to the post-purchase customer experience.
Every day, service reps are responding to questions via call centers or electronically about first-time product use, product capabilities, product support, and even a list of suggested product-compatible accessories. The list goes on and on, but they all signal a missed opportunity to influence the first half of the buyer journey. Very often, the questions answered during a post-purchase experience are the same shoppers have when making a transaction. However, there's a distinct difference between the two experiences: Buyers research for the answer while customers immediately access it through the brand's channels.
Just imagine the difference if common customer service inquiry information were readily available early in the sales cycle, as either unassisted or assisted help. How likely will your customer make the right purchase? Better yet, how much higher will your advocacy rates rise when customers choose the best product that fits their needs?
According to a July 2016 commissioned study conducted by Forrester Consulting on behalf of SAP, 71% of companies believe that buyers who use community content have greater product satisfaction than those who don't. Even though buyers are making it known that they prefer self-service options to find product information or support, many brands still come up short on information that can help complete the transaction.
This is where your customer service area can add value to the buyer journey. Most answers to your shoppers' questions already exist. Through the use of digital interactions such as brand-driven social community sites, your business can make product information and one-on-one expertise more accessible to customers.
However, it's not as easy as setting up the right experience and giving every potential customer access to your service reps. Like everything else in today's world, customer service needs to go through its own transformation to ensure every customer is given the right level of attention with the greatest efficiency and business impact as possible.
Focus on immediate response methods. The ultimate goal is to give customers what they want in the moment of need. Digital methods such as chat and video are two ways to provide this level of support. Other possible routes include web-based and mobile self-services such as discussion forums, product pages, and easy-to-search Q&A content in a social community environment.
Shed the cost-center view to embrace a profit-center mindset. By rethinking customer service as a sales tool, chat windows and "ask for help" buttons on brand domains can shorten the lead-to-transaction cycle and boost customer loyalty.
Reduce the volume of one-on-one interactions. Day in and day out, customer service reps are fielding questions – many of them are similar, if not exactly the same. Creating a repository of all previous responses empower buyers to explore them on their own. By providing greater visibility to frequent service discussions, you can significantly reduce the volume of one-on-one customer service requests.
No two customer journeys are the same. Some make a buying decision without the seller's assistance. Others jump around the purchase path, keeping brands guessing along the way. Anything is possible throughout the customer experience, especially in this digital era of shopping ruled by shared experiences and opinions.
Thanks to social channels such as Yelp, Facebook, Instagram, this information is easy to access. But unfortunately for brands, much of this content is either disconnected from the brand's customer channels or not available at all to support the customer journey experience.
The underlying theme of the new buyer journey is very simple: Knowledge is power and influence. Customers now have more interest in a salesperson with all the answers than watching the latest viral ad on their social feed. Although this realm has traditionally belonged to sales and marketing, it's no longer their problem – it's an opportunity for customer service.
Kick-start your customer service revolution today. Download the entire Forrester Consulting study, Supporting the Buyer Journey with Customer Service, to get started.


Thanks for shopping at The HOUSE Marketplace.
We only replace items if they are defective or damaged. If you need to exchange it for the same item, send us an email at letstalks@thehousemediagroup.com and send your item(s) to: 14 Connie Crescent, Unit 8, Concord, ON, L4K 2W8, Canada.
To return your product, you should ship your item(s) to: 14 Connie Crescent, Unit 8, Concord, ON, L4K 2W8, Canada.
Depending on where you live, the time it may take for your exchanged item(s) to reach you, may vary.