tutorials Archives - [RaHa] Programming 228-304-9202

How to Set Up a Signature in RoundCube Webmail

Overview

An email signature is a personalized block of text at the bottom of an email.

The Webmail interface (cPanel » Home » Email Accounts » Check Email ) does not have a setting for assigning a signature for your email to use. You will need to configure signatures within the Webmail Client that you use.

  1. Log into your webmail client.
  2. Click setting in the top-right section of the screen (circled).
  3. Click Identities (circled)
  4. Select the current email under Identities (circled).

5. Enter the details for this Identity in the fields. In the Signature section check the box for HTML.

6. You can now upload your custom signature as an image. Feel free to add any other details you may like to your custom signature.

How to add custom email signatures on iPhone and iPad

For this tutorial, we’ll cover how to add email signatures on iPhone and iPad when using the default Mail app. If you’re looking to add a signature via a third-party email client, take a look in settings of that particular app.

With the iOS Mail app, you can have a signature apply to all email accounts you are using, or have different signatures for each account.

How to add custom email signatures on iPhone and iPad

  1. Open Settings
  2. Swipe down and tap Mail
  3. Swipe down and select Signature
  4. Enter your signature (can be the same for all accounts or on per account basis)

Here’s how the process looks:

email signatures on iPhone

If you have an iPhone and an iPad, you’ll need to set up signatures on both devices as they don’t sync automatically. Follow the same steps as above.

Learning the blockchain by coding your own blockchain in GO!

Newcomers to blockchain mining rarely have a fundamental understanding of what exactly mining is and what is involved! You may have heard  stories of people filling up warehouses with GPUs making millions of dollars worth of cryptocurrencies a month. What exactly is cryptocurrency mining? How does it work? How can I try coding my own mining algorithm?

These questions and more will be answered in my three part series on blockchain mining which explains how to mine and write the code to mine so that you have total control over the process. The algorithm we’llstart with is called Proof of Work, which is the foundation to Bitcoin and Ethereum, the two most popular cryptocurrencies. Don’t worry, we’ll explain how that works shortly.

What is cryptocurrency mining?

Cryptocurrencies need to have scarcity in order to be valuable. If anyone could produce as many Bitcoin as they wanted at anytime, Bitcoin would be worthless as a currency (wait, doesn’t the Federal Reserve do this? *facepalm*). The Bitcoin algorithm releases some Bitcoin to a winning member of its network every 10 minutes, with a maximum supply to be reached in about 122 years. This release schedule also controls inflation to a certain extent, since the entire fixed supply isn’t released at the beginning. More are slowly released over time.

The process by which a winner is determined and given Bitcoin requires the winner to have done some “work”, and competed with others who were also doing the work. This process is called mining, because it’s analogous to a gold miner spending some time doing work and eventually (and hopefully) finding a bit of gold.

The Bitcoin algorithm forces participants, or nodes, to do this work and compete with each other to ensure Bitcoin aren’t released too quickly.

How does mining work?

A quick Google search of “how does bitcoin mining work?” fills your results with a multitude of pages explaining that Bitcoin mining asks a node (you, or your computer) to solve a hard math problem. While technically true, simply calling it a “math” problem is incredibly hand-wavy and hackneyed. How mining works under the hood is a lot of fun to understand. We’ll need to understand a bit of cryptography and hashing to learn how mining works.

A brief introduction to cryptographic hashes

One-way cryptography takes in a human readable input like “Hello world” and applies a function to it (i.e. the math problem) to produce an indecipherable output. These functions (or algorithms) vary in nature and complexity. The more complicated the algorithm, the harder it is to reverse engineer. Thus, cryptographic algorithms are very powerful in securing things like user passwords and military codes.

Let’s take a look at an example of SHA-256, a popular cryptographic algorithm. This hashing website lets you easily calculate SHA-256 hashes. Let’s hash “Hello world” and see what we get:

Try hashing “Hello world” over and over again. You get the same hash every time. In programming getting the same result again and again given the same input is calledidempotency.

A fundamental property of cryptographic algorithms is that they should be extremely hard to reverse engineer to find the input, but extremely easy to verify the output. For example, using the SHA-256 hash above, it should be trivial for someone else to apply the SHA-256 hash algorithm to “Hello world” to check that it indeed produces the same resultant hash, but it should be very hard to take the resultant hash and get “Hello world” from it. This is why this type of cryptography is called one way.

Bitcoin uses Double SHA-256, which is simply applying SHA-256 again to the SHA-256 hash of “Hello world”. For our examples throughout this tutorial we’ll just use SHA-256.

Mining

Now that we understand what cryptography is, we can get back to cryptocurrency mining. Bitcoin needs to find some way to make participants who want to earn Bitcoin “work” so Bitcoins aren’t released too quickly. Bitcoin achieves this by making the participants hash many combinations of letters and numbers until the resulting hash contains a specific number of leading “0”s.

For example, go back to the hash website and hash “886”. It produces a hash with 3 zeros as a prefix.

But how did we know that “886” produced something with 3 zeros? That’s the point. Before writing this blog, we didn’t. In theory, we would have had to work through a whole bunch combinations of letters and numbers and tested the results until we got one that matched the 3 zeros requirement. To give you a simple example, we already worked in advance to realize the hash of “886” produced 3 leading zeros.

The fact that anyone can easily check that “886” produces something with 3 leading zeros proves that we did the grunt work of testing and checking a large combination of letters and numbers to get to this result. So if I’m the first one who got this result, I would have earned the Bitcoin by proving I did this work — the proof is that anyone can quickly check that “886” produces the number of zeros I claim it does. This is why the Bitcoin consensus algorithm is called Proof-of-Work.

But what if I just got lucky and I got the 3 leading zeros on my first try? This is extremely unlikely and the occasional node that successfully mines a block (proves that they did the work) on their first try is outweighed by millions of others who had to work extra to find the desired hash. Go ahead and try it. Type in any other combination of letters and numbers in the hash website. We bet you won’t get 3 leading zeros.

Bitcoin’s requirements are a bit more complex than this (many more leading zeros!) and it is able to adjust the requirements dynamically to make sure the work required isn’t too easy or too hard. Remember, it aims to release Bitcoin every 10 minutes so if too many people are mining, it needs to make the proof of work harder to compensate. This is called adjusting the difficulty. For our purposes, adjusting the difficulty will just mean requiring more leading zeros.

So you can see the Bitcoin consensus algorithm is much more interesting than just “solving a math problem”!

Enough background. Let’s get coding!

Now that we have the background we need, let’s build our own Blockchain program with a Proof-of-Work algorithm. We’ll write it in Go because we use it here at Coral Health and frankly, it’s awesome.

First, you’ll need a program to code with. I’d suggest getting Visual Studio Code. It’s lightweight (unlike the full Visual Studio), free, and it’s scalable. Best of all, as you use different coding languages, you can import the capability to use them in VS Code easily and quickly.

Next, download Go!.

After installing and configuring Go, we’ll also want to grab the following packages:

go get github.com/davecgh/go-spew/spew

Spew allows us to view structs and slices cleanly formatted in our console. This is nice to have.

go get github.com/gorilla/mux

Gorilla/mux is a popular package for writing web handlers. We’ll need this.

go get github.com/joho/godotenv

Godotenv lets us read from a .env file that we keep in the root of our directory so we don’t have to hardcode things like our http ports. We’ll need this too.

Let’s also create a .env file in the root of our directory defining the port that will serve http requests. Just add one line to this file:

PORT=8080

Create a main.go file. Everything from now on will be written to this file and will be less than 200 lines of code. Let’s get coding!

Imports

Here are the imports we’ll need, along with our package declaration. Let’s write these to main.go

package main

import (
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"io"
	"log"
	"net/http"
	"os"
	"time"

	"github.com/davecgh/go-spew/spew"
	"github.com/gorilla/mux"
	"github.com/joho/godotenv"
)

Data model

Let’s define the struct of each of our blocks that will make up the blockchain. Don’t worry, we’ll explain what all of these fields mean in a minute.

type Block struct {
	Index     int
	Timestamp string
	UniqueId  int
	Hash      string
	PrevHash  string
}

Each Block contains data that will be written to the blockchain, and represents each case when you took your pulse rate (remember you did that at the beginning of the article?).

  • Index is the position of the data record in the blockchain
  • Timestamp is automatically determined and is the time the data is written
  • UniqueId is any unique 2 digit number you’d like to use
  • Hash is a SHA256 identifier representing this data record
  • PrevHash is the SHA256 identifier of the previous record in the chain

Let’s also model out the blockchain itself, which is simply a slice of Block:

var Blockchain []Block

So how does hashing fit into blocks and the blockchain? We use hashes to identify and keep the blocks in the right order. By ensuring the PrevHash in each Block is identical to Hash in the previous Block we know the proper order of the blocks that make up the

chain.

Hashing and Generating New Blocks

So why do we need hashing? We hash data for 2 main reasons:

  • To save space. Hashes are derived from all the data that is on the block. In our case, we only have a few data points but imagine we have data from hundreds, thousands or millions of previous blocks. It’s much more efficient to hash that data into a single SHA256 string or hash the hashes than to copy all the data in preceding blocks over and over again.
  • Preserve integrity of the blockchain. By storing previous hashes like we do in the diagram above, we’re able to ensure the blocks in the blockchain are in the right order. If a malicious party were to come in and try to manipulate the data (for example, to change our heart rate to fix life insurance prices), the hashes would change quickly and the chain would “break”, and everyone would know to not trust that malicious chain.

Let’s write a function that takes our Block data and creates a SHA256 hash of it.

func calculateHash(block Block) string {
	record := string(block.Index) + block.Timestamp + string(block.UniqueId) + block.PrevHash
	h := sha256.New()
	h.Write([]byte(record))
	hashed := h.Sum(nil)
	return hex.EncodeToString(hashed)
}

This calculateHash function concatenates IndexTimestampUniqueIdPrevHash of the Block we provide as an argument and returns the SHA256 hash as a string. Now we can generate a new Block with all the elements we need with a new generateBlock function. We’ll need to supply it the previous block so we can get its hash and our ID in UniqueId. Don’t worry about the UniqueId int argument that’s passed in. We’ll address that later.

func generateBlock(oldBlock Block, UniqueId int) (Block, error) {

	var newBlock Block

	t := time.Now()

	newBlock.Index = oldBlock.Index + 1
	newBlock.Timestamp = t.String()
	newBlock.UniqueId = UniqueId 
	newBlock.PrevHash = oldBlock.Hash
	newBlock.Hash = calculateHash(newBlock)

	return newBlock, nil
}

Notice that the current time is automatically written in the block with time.Now(). Also notice that our prior calculateHash function was called. PrevHash is copied over from the hash of the previous block. Index is incremented from the Index of the previous block.

Block Validation

Now we need to write some functions to make sure the blocks haven’t been tampered with. We do this by checking Index to make sure they’ve incremented as expected. We also check to make sure our PrevHash is indeed the same as the Hash of the previous block. Lastly, we want to double check the hash of the current block by running the calculateHash function again on the current block. Let’s write a isBlockValid function that does all these things and returns a bool. It’ll return true if it passes all our checks:

func isBlockValid(newBlock, oldBlock Block) bool {
	if oldBlock.Index+1 != newBlock.Index {
		return false
	}

	if oldBlock.Hash != newBlock.PrevHash {
		return false
	}

	if calculateHash(newBlock) != newBlock.Hash {
		return false
	}

	return true
}

What if we run into an issue where two nodes of our blockchain ecosystem both added blocks to their chains and we received them both. Which one do we pick as the source of truth? We choose the longest chain. This is a classic blockchain issue and has nothing to do with nefarious actors.

Two well meaning nodes may simply have different chain lengths, so naturally the longer one will be the most up to date and have the latest blocks. So let’s make sure the new chain we’re taking in is longer than the current chain we have. If it is, we can overwrite our chain with the new one that has the new block(s).

We simply compare the length of the slices of the chains to accomplish this:

func replaceChain(newBlocks []Block) {
	if len(newBlocks) > len(Blockchain) {
		Blockchain = newBlocks
	}
}

If you’ve made it this far, pat yourself on the back! We’ve basically written up the guts of our blockchain with all the various functions we need.

Now we want a convenient way to view our blockchain and write to it, ideally in a web browser so we can show our friends!

Web Server

We assume you’re already familiar with how web servers work and have a bit of experience wiring them up in Go. We’ll walk you through the process now.

We’ll be using the Gorilla/mux package that you downloaded earlier to do the heavy lifting for us.

Let’s create our server in a run function that we’ll call later.

func run() error {
	mux := makeMuxRouter()
	httpAddr := os.Getenv("ADDR")
	log.Println("Listening on ", os.Getenv("ADDR"))
	s := &http.Server{
		Addr:           ":" + httpAddr,
		Handler:        mux,
		ReadTimeout:    10 * time.Second,
		WriteTimeout:   10 * time.Second,
		MaxHeaderBytes: 1 << 20,
	}

	if err := s.ListenAndServe(); err != nil {
		return err
	}

	return nil
}

Note that port we choose comes from our .env file that we created earlier. We give ourselves a quick console message with log.Println to let us know the server is up and running. We configure the server a bit and then ListenAndServe. Pretty standard Go stuff.

Now we need to write the makeMuxRouter function that will define all our handlers. To view and write to our blockchain in a browser, we only need 2 routes and we’ll keep them simple. If we send a GET request to localhost we’ll view our blockchain. If we send a POST request to it, we can write to it.

func makeMuxRouter() http.Handler {
	muxRouter := mux.NewRouter()
	muxRouter.HandleFunc("/", handleGetBlockchain).Methods("GET")
	muxRouter.HandleFunc("/", handleWriteBlock).Methods("POST")
	return muxRouter
}

Here’s our GET handler:

func handleGetBlockchain(w http.ResponseWriter, r *http.Request) {
	bytes, err := json.MarshalIndent(Blockchain, "", "  ")
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	io.WriteString(w, string(bytes))
}

We simply write back the full blockchain, in JSON format, that we can view in any browser by visiting localhost:8080. We have our PORT variable set as 8080 in our `.env` file so if you change it, make sure to visit your correct port.

Our POST request is a little bit more complicated, but not by much. To start, we’ll need a new Message struct. We’ll explain in a second why we need it.

type Message struct {
	UniqueId int
}

Here’s the code for the handler that writes new blocks. We’ll walk you through it after you’ve read it.

func handleWriteBlock(w http.ResponseWriter, r *http.Request) {
	var m Message

	decoder := json.NewDecoder(r.Body)
	if err := decoder.Decode(&m); err != nil {
		respondWithJSON(w, r, http.StatusBadRequest, r.Body)
		return
	}
	defer r.Body.Close()

	newBlock, err := generateBlock(Blockchain[len(Blockchain)-1], m.UniqueId )
	if err != nil {
		respondWithJSON(w, r, http.StatusInternalServerError, m)
		return
	}
	if isBlockValid(newBlock, Blockchain[len(Blockchain)-1]) {
		newBlockchain := append(Blockchain, newBlock)
		replaceChain(newBlockchain)
		spew.Dump(Blockchain)
	}

	respondWithJSON(w, r, http.StatusCreated, newBlock)

}

The reason we used a separate Message struct is to take in the request body of the JSON POST request we’ll use to write new blocks. This allows us to simply send a POST request with the following body and our handler will fill in the rest of the block for us:

{"UniqueId":50}

The 50 is an example UniqueId. Use your own by changing that integer to your own UniqueId.

After we’re done decoding the request body into our var m Message struct, we create a new block by passing in the previous block and our new pulse rate into the generateBlock function we wrote earlier . This is everything the function needs to create a new block. We do a quick check to make sure the new block is kosher using the isBlockValid function we created earlier.

A couple notes
  • spew.Dump is a convenient function that pretty prints our structs into the console. It’s useful for debugging.
  • for testing POST requests, we like to use Postmancurl works well too, if you just can’t get away from the terminal.

When our POST requests are successful or unsuccessful, we want to be alerted accordingly. We use a little wrapper function respondWithJSON to let us know what happened. Remember, in Go, never ignore errors. 

func respondWithJSON(w http.ResponseWriter, r *http.Request, code int, payload interface{}) {
	response, err := json.MarshalIndent(payload, "", "  ")
	if err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte("HTTP 500: Internal Server Error"))
		return
	}
	w.WriteHeader(code)
	w.Write(response)
}
Almost done!

Let’s wire all these different blockchain functions, web handlers and the web server in a short, clean main function:

func main() {
	err := godotenv.Load()
	if err != nil {
		log.Fatal(err)
	}

	go func() {
		t := time.Now()
		genesisBlock := Block{0, t.String(), 0, "", ""}
		spew.Dump(genesisBlock)
		Blockchain = append(Blockchain, genesisBlock)
	}()
	log.Fatal(run())

}

So what’s going on here?

  • godotenv.Load() allows us to read in variables like our port number from the.env file we placed at the root of our directory so we don’t have to hardcode them (gross!) throughout our app.
  • genesisBlock is the most important part of the main function. We need to supply our blockchain with an initial block, or else a new block will not be able to compare its previous hash to anything, since a previous hash doesn’t exist.
  • We isolate the genesis block into its own go routine so we can have a separation of concerns from our blockchain logic and our web server logic. This will work without the go routine but it’s just cleaner this way.

Tada! We’re done!

How to build a cryptomining rig: Bitcoin mining

Cryptocurrency has been — and continues to be — a wild ride. 

I’m old enough to remember being given a couple of bitcoins when they were worth next to nothing. Needless to say, I don’t have them anymore. Now, with bitcoin and other cryptocurrency prices skyrocketing again, there’s renewed interest in cryptomining, which is a way to accumulate cryptocurrency without having to pay for it.

Let’s take a look at what makes a good cryptomining rig, and what hardware it takes if you want to be serious about mining.

What is cryptomining?

In the most basic terms, you are using a computer (or computers) to solve cryptographic equations and record that data to a blockchain. Taking this a bit deeper, miners verify the hashes of unconfirmed blocks and receive a reward for every hash that is verified. The process is computationally intensive, requiring state-of-the-art hardware if you are planning on making much headway with mining. Mining, as it was back in the days of the gold rush, is not for the faint of heart. 

And as with all high-end systems, it’s less a case of how much do you want to spend, and more a case of how fast do you want to spend. So, what hardware do you need to mine cryptocurrency?

What is a cryptomining rig?

OK, the “rig” is essentially a customized PC. It has all the common elements of a PC: CPU, motherboard, RAM, and storage. Where things deviate from the norm is when it comes to the graphics cards. It’s the GPU that’s doing that hard work when it comes to mining cryptocurrency, and not the CPU. You’re going to need quite a powerful GPU for mining, and likely you are going to be buying more than one. A lot more.

In fact, you can think of a mining rig as a relatively cheap PC with one or more high-performance GPUs attached. You need to connect multiple graphics cards to a single system, which means you also need a motherboard to handle that. You’ll also be looking at more than one power supply unit (PSU) if you’re planning to push things to the extremes.

There are also some other mining-specific items you’ll need to make the mining rig ready for mining.

MINING RIG CONSIDERATIONS

Here are a few considerations to bear in mind when building a mining rig:

  • It’s not going to be cheap! 
  • You need to factor power consumption in your mining equation because that can eat into your earnings.
  • You’re not building a regular PC, and getting everything to work can become a game of trial and error and a lot of fiddling with drivers. Be patient!

WHY ARE GRAPHICS CARDS PRICES SO ASTRONOMICAL?

Prices are being driven high by two factors:

  • Supply chain issues causing backlogs
  • In order to prevent high demand from miners causing even more issues, most cards now feature LHR (Lite Hash Rate) to limit mining speeds, making them less desirable for cryptomining. The card listed below is not limited, so the price making it perfect for mining.

Motherboard

Asus B250 Mining Expert

OK, let’s start with the motherboard. The Asus B250 Mining Expert is a beast of a motherboard, capable of having 19 graphics cards connected to it. That’s a lot. The board isn’t new — it was released in 2017 — and it is finicky when it comes to setting up (it needs a specific layout of AMD and Nvidia graphics cards),

Asus has published recommend GPU layouts for 19-, 13-, and 11-card for this board, and while other layouts might work, I recommend staying with what the manufacturer suggests, as veering away from this is a recipe for a serious — not to mention expensive — headaches.  

Note: Asus recommends running Windows 10 with this motherboard. $999 at Newegg

CPU

Intel Core i5-6500

There’s no real point in overspending on a CPU for a mining rig since it’s the GPU’s that are doing the hard work. This quad-core Core i5 is perfect for this setup and works great with the motherboard chosen above.$140 at Newegg

RAM

G.SKILL Aegis 16GB (2 x 8GB)

You’re not going to overspend on RAM either. The motherboard supports DDR4 2400, and this 2x8GB kit from G.SKILL fits the bill. $55 at Newegg

Storage

SanDisk SSD Plus 1TB

I’d install a couple of these 1TB SSDs. At under $100 each, they’re perfect for this kind of application. You could go with HDDs, but I prefer going with SSDs nowadays.

Also: Best external hard drives$85 at Newegg

PSU

Segotep 850W Full-Modular PSU

Depending on how many graphics cards you have installed, you may need multiple PSUs. It’s tempting to find the cheapest possible, but since they are going to be pushed hard, I recommend paying a little more.

These Segotep PSUs are middle-of-the-road good value, yet they offer reliable performance. The modular nature also means that you’re not turning the mining rig into a spaghetti of wires.$104 at Newegg

PCI-e Riser

FebSmart 16x to 1x Powered Riser 6-pack

Even if you’ve built a PC in the past, I bet you’ve not had to fit in PCI-E risers. This is where a bitcoin mining rig differs from a regular PC in that you can’t have all the graphics cards directly attached to the motherboard, so these risers allow you to connect them indirectly.

You’re going to need one of these for every card you connect (other than the card that goes into the x16 PCI-e slot). This six-pack of powered risers are great and provide stable power to your graphics cards.

I do not recommend using non-powered risers. I’ve had nothing but problems with stability using them in the past in cryptomining rigs, so don’t make the same mistake I made!$65 at Newegg

Nvidia graphics card

MSI Ventus 3X GeForce RTX 3090

This is a great card and everything you’re looking for in a mining rig. Loads of potential for overclocking, stable, and great cooling. Another nice side benefit is that it’s quite an efficient card, which means lower power consumption and reduced mining costs.

And, unlike a lot of graphics cards nowadays, this does not feature LHR (Lite Hash Rate) to limit mining speeds.

  • 24GB 384-Bit GDDR6X
  • Boost Clock 1725 MHz
  • 1 x HDMI 2.1 3 x DisplayPort 1.4a
  • 10496 CUDA Cores
  • PCI Express 4.0

How to use CheckBox in Android

CheckBox belongs to android.widget.CheckBox class. Android CheckBox class is the subclass of CompoundButton class. It is generally used in a place where user can select one or more than choices from a given list of choices. For example, selecting hobbies.

public class CheckBox extends CompoundButton

Class Hierarchy :

java.lang.Object
   ↳  android.view.View
        ↳  android.widget.TextView
             ↳  android.widget.Button
                  ↳  android.widget.CompoundButton
                       ↳  android.widget.CheckBox

It has two states – checked or unchecked.

Methods of CheckBox class

  • public boolean isChecked(): If CheckBox is in checked state then return true otherwise false.
  • public void setChecked(boolean status): It changes the state of the CheckBox.

Below is the code for an example where the user chooses its hobbies from the given list containing Painting, Reading, Singing and Cooking with the help of CheckBox.

MainActivity.java

//Below is the code for MainActivity.java
  
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.CheckBox;
import android.widget.Toast;
  
public class MainActivity extends AppCompatActivity {
    CheckBox ch, ch1, ch2, ch3;
  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
  
        // Binding MainActivity.java with activity_main.xml file
        setContentView(R.layout.activity_main);
  
        // Finding CheckBox by its unique ID
        ch=(CheckBox)findViewById(R.id.checkBox);
        ch1=(CheckBox)findViewById(R.id.checkBox2);
        ch2=(CheckBox)findViewById(R.id.checkBox3);
        ch3=(CheckBox)findViewById(R.id.checkBox4);
    }
  
    // This function is invoked when the button is pressed.
    public void Check(View v)
    {
        String msg="";
  
        // Concatenation of the checked options in if
          
        // isChecked() is used to check whether 
        // the CheckBox is in true state or not.
  
        if(ch.isChecked())        
            msg = msg + " Painting ";
        if(ch1.isChecked())
            msg = msg + " Reading ";
        if(ch2.isChecked())
            msg = msg + " Singing ";
        if(ch3.isChecked())
            msg = msg + " Cooking ";
  
        // Toast is created to display the 
        // message using show() method.
        Toast.makeText(this, msg + "are selected", 
                       Toast.LENGTH_LONG).show();
    }
}

 
activity_main.xml

The activity_main.xml has a TextView, 4 CheckBoxes and a button.The TextView prompts the user to select his/her hobbies.
First user select its choices and then presses the Submit button. After pressing Submit button, a toast will generate showing the selected hobbies.


<!-- Below is the code for activity_main.xml -->
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ffffff"
    android:orientation="vertical"
    tools:context="com.example.hp.checkbox.MainActivity">

    <TextView
        android:id="@+id/textView"

    <!-- covers the entire width of the screen -->
    android:layout_width="match_parent"

    <!-- covers as much height as required. -->
    android:layout_height="wrap_content"

    <!--create 8dp space from margin ends-->
    android:layout_marginEnd="8dp"

    <!--create 8dp space from start of margin-->
    android:layout_marginStart="8dp"

    <!--create 48dp space from the top of margin-->
    android:layout_marginTop="48dp"

    android:text="Choose your hobbies:"
    android:textSize="24sp"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toTopOf="parent" />

    <CheckBox
        android:id="@+id/checkBox"

    <!-- covers the entire width of the screen -->
    android:layout_width="match_parent"

    <!-- covers as much height as required. -->
    android:layout_height="wrap_content"

    android:text="Painting"
    android:layout_marginTop="16dp"
    android:textSize="18sp" />

    <CheckBox
        android:id="@+id/checkBox2"

    <!-- covers the entire width of the screen -->
    android:layout_width="match_parent"

    <!-- covers as much height as required. -->
    android:layout_height="wrap_content"

    android:text="Reading"
    android:layout_marginTop="16dp"
    android:textSize="18sp" />

    <CheckBox
        android:id="@+id/checkBox3"

    <!-- covers the entire width of the screen -->
    android:layout_width="match_parent"

    <!-- covers as much height as required. -->
    android:layout_height="wrap_content"

    android:layout_marginTop="16dp"
    android:text="Singing"
    android:textSize="18sp"
    app:layout_constraintTop_toTopOf="@+id/textView"
    tools:layout_editor_absoluteX="382dp" />

    <CheckBox
        android:id="@+id/checkBox4"

    <!-- covers the entire width of the screen -->
    android:layout_width="match_parent"

    <!-- covers as much height as required. -->
    android:layout_height="wrap_content"

    android:text="Cooking"
    android:layout_marginTop="16dp"
    android:textSize="18sp"
    app:layout_constraintTop_toBottomOf="@+id/checkBox"
    tools:layout_editor_absoluteX="386dp" />

    <Button
        android:id="@+id/button"

    <!-- covers the entire width of the screen -->
    android:layout_width="match_parent"

    <!-- covers as much height as required. -->
    android:layout_height="wrap_content"

    android:layout_marginTop="16dp"
    android:onClick="Check"
    android:text="submit" />
</LinearLayout>


TextureView: How to create a full-screen video background in Android applications

Video Cropping

In this part of Android SurfaceView story we are going to create application which will do the following:

  • display video from assets folder using TextureView.
  • display a full screen background video without distorting the video size

This tutorial is derived from the creation of our latest app, TrackBack – available on the play store soon. Some XML names and items have been changed slightly to suite this tutorial. We used royalty free video and a basic video editor to adjust the video size and combine clips.

Final Results:

Step 1 – Preparing

Create Android project and target Android version 4.0. Make sure you have following lines in your AndroidManifest.xml file.

<uses-sdk
    android:minSdkVersion="14"
    android:targetSdkVersion="14"/>

Step 2 – XML

Copy a video file to your assets folder at res/raw. If raw doesn’t exist, make it.

In your values folder create dimen.xml file and add following lines.

<!-- common settings -->
<dimen name="padding_left_right">23dp</dimen>
<dimen name="margin_left_right">23dp</dimen>
<dimen name="margin_left_right_large">50dp</dimen>
<dimen name="margin_top_bottom">30dp</dimen>
<dimen name="margin_top_bottom_lg">90dp</dimen>
<dimen name="margin_btn_lg">50dp</dimen>
<dimen name="text_btn_lg">21dp</dimen>
<dimen name="margin_top_bottom_alt">45dp</dimen>
<dimen name="heading_lg">35sp</dimen>
<dimen name="heading_md">21sp</dimen>

In your values folder create string.xml file and add following lines – adjusting appropriately.

<!-- app required strings -->
<string name="app_name">TrackBack</string>
<!-- Strings related to login -->
<string name="welcome_login">Do you have an account? Sign in</string>
<string name="welcome_msg">Keep track of everyone and everything you love... in real time!</string>

In your layout folder create activity_video_crop.xml file or any appropriate name for this in your app.. and add following lines:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/welcome_constraint"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".Activity_Welcome">

    <FrameLayout
        android:id="@+id/welcome_frame"
        android:layout_width="match_parent"
        android:layout_height="match_parent">

    <TextureView
        android:id="@+id/videoview"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:layout_gravity="center"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintBottom_toBottomOf="parent"

        >
    </TextureView>

    <androidx.constraintlayout.widget.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="@color/colorPrimarySeeThrough"
        >
    <ImageView
        android:layout_width="55dp"
        android:layout_height="55dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        android:layout_marginTop="@dimen/margin_top_bottom_lg"
        android:id="@+id/welcome_logo"
        android:src="@drawable/logo_white"
        />
        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_margin="@dimen/margin_left_right"
            android:id="@+id/welcome_text"
          app:layout_constraintTop_toBottomOf="@+id/welcome_logo"
            android:text="@string/app_name"
            android:textSize="@dimen/heading_lg"
            android:textColor="@color/white"
            android:textStyle="bold"
            android:textAlignment="center"
            />
        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:layout_marginBottom="90dp"
            android:layout_marginRight="@dimen/margin_left_right"
            android:layout_marginLeft="@dimen/margin_left_right"
            android:id="@+id/welcome_note_2"
          app:layout_constraintBottom_toBottomOf="@+id/btn_start"
            android:text="@string/welcome_msg"
            android:textSize="@dimen/heading_md"
            android:textColor="@color/white"
            android:backgroundTint="@color/white"
            android:textAlignment="center"
            />
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
           android:background="@drawable/rounded_top_bottom_blue"
            android:text=" Continue "
            android:textSize="@dimen/text_btn_lg"
            android:textAlignment="center"
            android:gravity="center"
            android:foregroundGravity="center"
            android:textColor="@color/slight_white"
     app:layout_constraintBottom_toBottomOf="@id/welcome_sign_in"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
       android:layout_marginBottom="@dimen/margin_top_bottom_alt"
            android:layout_marginLeft="@dimen/margin_btn_lg"
            android:layout_marginRight="@dimen/margin_btn_lg"
            android:id="@+id/btn_start"
            />
        <TextView
            android:id="@+id/welcome_sign_in"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
            android:textSize="20dp"
            android:textColor="@color/slight_white"
            android:text="@string/welcome_login"
        android:layout_marginBottom="@dimen/margin_top_bottom_lg"
            />
    </androidx.constraintlayout.widget.ConstraintLayout>
    </FrameLayout>
</androidx.constraintlayout.widget.ConstraintLayout>

Note: All that’s required here is the FrameLayout and the TextureView. I prefer using ConstraintLayout as the root to easily position items.

Step 3 – Basic code

Create a new activity class and call it ActivityCrop or something appropriate. Don’t forget to declare it inside AndroidManifest.xml file.

Imports:

package com.rahaprogramming.trackback;

import android.content.Context;
import android.graphics.Matrix;
import android.graphics.SurfaceTexture;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Bundle;
import android.util.Log;
import android.view.Surface;
import android.view.TextureView;
import android.widget.FrameLayout;
import androidx.appcompat.app.AppCompatActivity;
public class Activity_Welcome extends AppCompatActivity implements
        TextureView.SurfaceTextureListener, MediaPlayer.OnCompletionListener {
    //declare class variables
    Context context = this;
    Uri video_uri;
    
    // MediaPlayer instance
    private MediaPlayer mMediaPlayer;
    //views
    private TextureView mTextureView;
    FrameLayout frameLayout;
    Surface surface;
    // Original video size - we created this video and knew the size.
    // for unknown size - use meta data
    private float mVideoWidth = 1080;
    private float mVideoHeight = 1440;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_welcome);
        //Toolbar toolbar = findViewById(R.id.toolbar);
        //setSupportActionBar(toolbar);
        video_uri = Uri.parse("android.resource://"+getPackageName()+"/"+R.raw.trackback);

        //set views
        mTextureView = findViewById(R.id.videoview);
        mTextureView.setClickable(false);
        frameLayout = findViewById(R.id.welcome_frame);

        //init MediaPlayer
        mMediaPlayer = new MediaPlayer();

        //set implemented listeners
        mMediaPlayer.setOnCompletionListener(this);
        mTextureView.setSurfaceTextureListener(this);
    }
    //plays the video
    private void playVideo() {
        //its a big file - use separate thread
        new Thread(new Runnable() {
            public void run() {
                try {
                    mMediaPlayer.setDataSource(context,video_uri);
                    mMediaPlayer.setLooping(true);
                    mMediaPlayer.prepareAsync();
                    // Play video when the media source is ready for playback.
                    mMediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                        @Override
                        public void onPrepared(MediaPlayer mediaPlayer) {
                            mediaPlayer.start();
                        }
                    });
                } catch (Exception e) { // I can split the exceptions to get which error i need.
                    Utils.log("Error: "+e.toString());
                    e.printStackTrace();
                }
            }
        }).start();
    }
    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surfaceTexture, int width, int height) {
        //set surface
        surface = new Surface(surfaceTexture);
        mMediaPlayer.setSurface(surface);
        //update viewable area
        updateTextureViewSize(width, height);
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surfaceTexture, int width, int height) {
        //set surface
        surface = new Surface(surfaceTexture);
        mMediaPlayer.setSurface(surface);
        //update viewable area
        updateTextureViewSize(width, height);
    }

    //uses the view width to determine best crop to fit the screen
    //@param int viewWidth width of viewport
    //@param int viewHeight height of viewport
    private void updateTextureViewSize(int viewWidth, int viewHeight) {
        float scaleX = 1.0f;
        float scaleY = 1.0f;

        Utils.log(viewWidth+" "+viewHeight+" "+mVideoHeight+" "+mVideoWidth);
        if (mVideoWidth > viewWidth && mVideoHeight > viewHeight) {
            scaleX = mVideoWidth / viewWidth;
            scaleY = mVideoHeight / viewHeight;
        } else if (mVideoWidth < viewWidth && mVideoHeight < viewHeight) {
            scaleY = viewWidth / mVideoWidth;
            scaleX = viewHeight / mVideoHeight;
        } else if (viewWidth > mVideoWidth) {
            scaleY = (viewWidth / mVideoWidth) / (viewHeight / mVideoHeight);
        } else if (viewHeight > mVideoHeight) {
            scaleX = (viewHeight / mVideoHeight) / (viewWidth / mVideoWidth);
        }

        // Calculate pivot points, in our case crop from center
        int pivotPointX = viewWidth / 2;
        int pivotPointY = viewHeight / 2;

        Matrix matrix = new Matrix();
        matrix.setScale(scaleX, scaleY, pivotPointX, pivotPointY);
        //transform the video viewing size
        mTextureView.setTransform(matrix);
        //set the width and height of playing view
        mTextureView.setLayoutParams(new FrameLayout.LayoutParams(viewWidth, viewHeight));
        //finally, play the video
        playVideo();
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        return false;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {

    }

    // callback when the video is over
    public void onCompletion(MediaPlayer mp) {
        //if this happens.. never will.. just restart the video
        mp.stop();
        mp.release();
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (mMediaPlayer != null) {
            // Make sure we stop video and release resources when activity is destroyed.
            mMediaPlayer.stop();
            mMediaPlayer.release();
            mMediaPlayer = null;
        }
    }
}

Step 5 – Video cropping

The resizing is done by the updateTextureViewSize method. First we need to calculate scaleX and scaleY factor and set it to Matrix object using method setScale(..). Next pass this matrix to TextureView by setTransform(..) method and you are done.

//uses the view width to determine best crop to fit the screen
    //@param int viewWidth width of viewport
    //@param int viewHeight height of viewport
    private void updateTextureViewSize(int viewWidth, int viewHeight) {
        float scaleX = 1.0f;
        float scaleY = 1.0f;

        Utils.log(viewWidth+" "+viewHeight+" "+mVideoHeight+" "+mVideoWidth);
        if (mVideoWidth > viewWidth && mVideoHeight > viewHeight) {
            scaleX = mVideoWidth / viewWidth;
            scaleY = mVideoHeight / viewHeight;
        } else if (mVideoWidth < viewWidth && mVideoHeight < viewHeight) {
            scaleY = viewWidth / mVideoWidth;
            scaleX = viewHeight / mVideoHeight;
        } else if (viewWidth > mVideoWidth) {
            scaleY = (viewWidth / mVideoWidth) / (viewHeight / mVideoHeight);
        } else if (viewHeight > mVideoHeight) {
            scaleX = (viewHeight / mVideoHeight) / (viewWidth / mVideoWidth);
        }

        // Calculate pivot points, in our case crop from center
        int pivotPointX = viewWidth / 2;
        int pivotPointY = viewHeight / 2;

        Matrix matrix = new Matrix();
        matrix.setScale(scaleX, scaleY, pivotPointX, pivotPointY);
        //transform the video viewing size
        mTextureView.setTransform(matrix);
        //set the width and height of playing view
        mTextureView.setLayoutParams(new FrameLayout.LayoutParams(viewWidth, viewHeight));
        //finally, play the video
        playVideo();
    }

Step 6 – Launch

When you launch application, you should notice that video is cropped correctly and displayed properly now. Of course, when width to height ratio is too big, video looses it quality as is scaled too much – as in:
ImageView.setScaleType(ImageVIew.ScaleType.CENTER_CROP);

Dogecoin Mining: How to Mine Dogecoin – Beginners Guide

So, where would you like to start? The beginning? Great choice. Let’s have a quick look at how Dogecoin got started.

Table of Contents

  • 1. A (Very) Short History of Dogecoin
  • 2. Understanding Crypto Mining Bottom Line
  • 3. What is Dogecoin Mining?
  • 4.Mining Comparison
  • 5. How to Mine Dogecoin  
  • 5.1. Dogecoin Mining: Solo vs Pool
  • 5.2. What You Need To Start Mining Dogecoin
  • 5.3. Dogecoin Mining Hardware
  • 5.4. Dogecoin Mining Software
  • 5.5. Dogecoin Cloud Mining
  • 6. So, Is Dogecoin Mining Profitable?

A (Very) Short History of Dogecoin

In 2013, an Australian named Jackson Palmer and an American named Billy Markus became friends. They became friends because they both liked cryptocurrencies. However, they also thought the whole thing was getting too serious so they decided to create their own.

Palmer and Markus wanted their coin to be more fun and more friendly than other crypto coins. They wanted people who wouldn’t normally care about crypto to get involved.

Dogecoin mining: Dogecoin homepage.

They decided to use a popular meme as their mascot — a Shiba Inu dog.

Dogecoin was launched on December 6th2013. Since then it has become popular because it’s playful and good-natured. Just like its mascot!

Dogecoin has become well-known for its use in charitable acts and online tipping. In 2014, $50,000 worth of Dogecoin was donated to the Jamaican Bobsled Team so they could go to the Olympics. Dogecoin has also been used to build wells in KenyaIsn’t that awesome!

Users of social platforms – like Reddit – can use Dogecoin to tip or reward each other for posting good content.

Dogecoin has the 27th largest market cap of any cryptocurrency.

Note: A market cap (or market capitalization) is the total value of all coins on the market.

So, Dogecoin is a popular altcoin, known for being fun, friendly and kind. It’s a coin with a dog on it! You love it already, don’t you?

Next, I want to talk about how mining works

Understanding Crypto Mining Bottom Line

To understand mining, you first need to understand how cryptocurrencies work. Cryptocurrencies are peer-to-peer digital currencies. This means that they allow money to be transferred from one person to another without using a bank.

Every cryptocurrency transaction is recorded on a huge digital database called a blockchain. The database is stored across thousands of computers called nodes. Nodes put together groups of new transactions and add them to the blockchain. These groups are called blocks.

Each block of transactions has to be checked by all the nodes on the network before being added to the blockchain. If nodes didn’t check transactions, people could pretend that they have more money than they really do (I know I would!).

Confirming transactions (mining) requires a lot of computer power and electricity so it’s quite expensive.

Blockchains don’t have paid employees like banks, so they offer a reward to users who confirm transactions. The reward for confirming new transactions is new cryptocurrency. The process of being rewarded with new currency for confirming transactions is what we call “mining”!

Dogecoin mining meme

It is called mining because it’s a bit like digging for gold or diamonds. Instead of digging with a shovel for gold, you’re digging with your computer for crypto coins!

Each cryptocurrency has its own blockchain. Different ways of mining new currency are used by different coins where different rewards are offered.

So, how do you mine DogecoinWhat’s special about Dogecoin mining? Let’s see…

What is Dogecoin Mining?

Dogecoin mining is the process of being rewarded with new Dogecoin for checking transactions on the Dogecoin blockchain. Simple, right? Well no, it’s not quite that simple, nothing ever is!

Mining Dogecoin is like a lottery. To play the lottery you have to do some work. Well, actually your computer (or node) has to do some work! This work involves the confirming and checking of transactions which I talked about in the last section.

Purchasing Dogecoin takes much less effort, especially when using Binance or Kraken. This is the time when Dogecoin reached its all-time high and keeps increasing in price significantly. So if you do it now, you might still get on that train! The price of Dogecoin increased by more than 300% percent in one day, as you can see in the chart below.Buy Dogecoin: Dogecoin price.Buy Dogecoin on Binance NOW!

Lots of computers work on the same block of transactions at the same time but the only one can win the reward of new coins. The one that earns the new coins is the node that adds the new block of transactions to the old block of transactions. This is completed using complex mathematical equations.

The node that solves the mathematical problem first wins! It can then attach the newly confirmed block of transactions to the rest of the blockchain.

Most cryptocurrency mining happens this way. However, Dogecoin mining differs from other coins in several important areas. These areas are:

  • Algorithm: Each cryptocurrency has a set of rules for mining new currency. These rules are called a mining or hashing algorithm.
  • Block Time: This is the average length of time it takes for a new block of transactions to be checked and added to the blockchain.
  • Difficulty: This is a number that represents how hard it is to mine each new block of currency. You can use the difficulty number to work out how likely you are to win the mining lottery. Mining difficulty can go up or down depending on how many miners there are. The difficulty is also adjusted by the coin’s protocol to make sure that the block time stays the same.
  • Reward: This is the amount of new currency that is awarded to the miner of each new block.

Now, let’s compare how DogeCoin mining works compared to Litecoin and Bitcoin

Mining Comparison

 LitecoinBitcoinDogecoin
AlgorithmScryptSHA-256Scrypt
Difficult6802626.09553511060552899.722798252.1991
Block Time (In Minutes)2.5101
Reward (Per Block)2512.510,000
Reward (Per Block in USD)3,027.3586,391.6327.36

Source: www.coinwarz.com

Bitcoin uses SHA-256 to guide the mining of new currency and the other two use Scrypt. This is an important difference because Scrypt mining needs a lot less power and is a lot quicker than SHA-256. This makes mining easier for miners with less powerful computers. Fans of Litecoin and Dogecoin think that they are fairer than Bitcoin because more people can mine them.

Note: In 2014, Litecoin and Dogecoin merged mining. This means they made it possible to mine both coins in the same process. Dogecoin mining is now linked with Litecoin mining. It’s like two different football teams playing home games in the same stadium!

Mining Dogecoin is a lot faster than mining Litecoin or Bitcoin. The block reward is much higher too!

Don’t get too excited though (sorry!). Dogecoin is still worth a lot less than Bitcoin and Litecoin. A reward of ten thousand Dogecoin is worth less than thirty US Dollars. A reward of 12.5 Bitcoin is currently worth 86,391.63 US Dollars! 

Dogecoin Mining: How to Mine Dogecoin - Beginners Guide

Note: The numbers might be slightly different by the time you’re reading this guide. 

However, it’s not as bad as it sounds. Dogecoin mining difficulty is more than one million times less than Bitcoin mining difficulty. This means you are much more likely to win the block reward when you mine Dogecoin.

Now I’ve told you about what Dogecoin mining is and how it works, would you like to give it a try?

Let’s see what you need to do to become a Dogecoin miner…

How to Mine Dogecoin  

There are two ways to mine Dogecoinsolo (by yourself) or in a Dogecoin mining pool.

Note: A Dogecoin pool is a group of users who share their computing power to increase the odds of winning the race to confirm transactions. When one of the nodes in a pool confirms a transaction, it divides the reward between the users of the pool equally.

Dogecoin Mining: Solo vs Pool

When you mine as a part of a Dogecoin pool, you have to pay fees. Also, when the pool mines a block you will only receive a small portion of the total reward. However, pools mine blocks much more often than solo miners. So, your chance of earning a reward (even though it is shared) is increased. This can provide you with a steady new supply of Dogecoin.

If you choose to mine solo then you risk waiting a long time to confirm a transaction because there is a lot of competition. It could be weeks or even months before you mine your first block! However, when you do win, the whole reward will be yours. You won’t have to share it or pay any fees.

As a beginner, I would recommend joining a Dogecoin pool. This way you won’t have to wait as long to mine your first block of new currency. You’ll also feel like you’re part of the community and that’s what Dogecoin is all about!

What You Need To Start Mining Dogecoin

Before you start Dogecoin mining, you’ll need a few basics. They are:

  • A PC with either Windows, OS X or Linux operating system.
  • An internet connection.
  • A Shiba Inu puppy (just kidding!).

You’ll also need somewhere to keep the Dogecoin you mine. It’s not recommended to choose online wallets, pick software or hardware wallets instead. They include Ledger Nano STrezor Model T and Coinbase. The latter option is a software wallet, whereas the first two are hardware wallets. 

Note: A wallet is like an email account. It has a public address for sending/receiving Dogecoin and a private key to access them. Your private keys are like your email’s password. Private keys are very important and need to be kept completely secure. 

dogecoin mining

There are two different types; a light wallet and a full wallet. To mine Dogecoin, you’ll need the full wallet. It’s called Dogecoin Core.

Now that you’ve got a wallet, you need some software and hardware.

Dogecoin Mining Hardware

You can mine Dogecoin with:

  • Your PC’s CPU: The CPU in your PC is probably powerful enough to mine Dogecoin. However, it is not recommended. Mining can cause less powerful computers to overheat which causes damage.
  • A GPU: GPUs (or graphics cards) are used to improve computer graphics but they can also be used to mine Dogecoin. There are plenty of GPUs to choose from but here are a few to get you started:
  • A Scrypt ASIC Miner: This is a piece of hardware designed to do one job only. Scrypt ASIC miners are programmed to mine scrypt based currencies like Litecoin and Dogecoin. ASIC miners are very powerful. They are also very expensive, very loud and can get very hot! Here’s a few for you to check out:
    • Innosilicon A2 Terminator ($760)
    • Bitmain Antminer L3 ($1,649)
    • BW L21 Scrypt Miner ($7,700)

Dogecoin Mining Software

Whether you’re mining with an ASIC, a GPU or a CPU, you’ll need some software to go with it. You should try to use the software that works best with the hardware you’re using. Here’s a short list of the best free software for each choice of mining hardware;

  • CPU: If you just want to give mining a quick try, using your computer’s CPU will work fine. The only software I would recommend for mining using a CPU only is CPU miner which you can download for free here.
  • GPU: If you mine with a GPU there are more software options. Here are a few to check out;
    • CudaMiner–  Works best with Nvidia products.
    • CGminer–  Works with most GPU hardware.
    • EasyMiner–  User-friendly, so it’s good for beginners.
  • Scrypt ASIC miner:
    • MultiMiner– Great for mining scrypt based currencies like Litecoin and Dogecoin. It can also be used to mine SHA-256 currencies like Bitcoin.
    • CGminer and EasyMiner can also be used with ASIC miners.

Recommendations

You’re a beginner, so keep it simple! When you first start mining Dogecoin I would recommend using a GPU like the Radeon RX 580 with EasyMiner software. Then I would recommend joining a Dogecoin mining pool. The best pools to join are multi-currency pools like Multipool or AikaPool.

Dogecoin Mining: How to Mine Dogecoin - Beginners Guide

If you want to mine Dogecoin but don’t want to invest in all the tech, there is one other option…

Dogecoin Cloud Mining

Cloud mining is mining without mining! Put simply, you rent computer power from a huge data center for a monthly or yearly fee. The Dogecoin is mined at the center and then your share is sent to you.

All you need to cloud mine Dogecoin is a Dogecoin wallet. Then choose a cloud mining pool to join. EobotNice Hash and Genesis Mining all offer Scrypt-based cloud mining for a monthly fee.

There are pros and cons to Dogecoin cloud mining.

The Pros

  • It’s cheaper than setting up your own mining operation. There’s also no hot, noisy hardware lying around the house!
  • As a beginner, there isn’t a lot of technical stuff to think about.
  • You get a steady supply of new currency every month.

The Cons

  • Cloud mining pools don’t share much information about themselves and how they work. It can be hard to work out if a cloud mining contract is a good value for money.
  • You are only renting computer power. If the price of Dogecoin goes down, you will still have to pay the same amount for something that is worthless.
  • Dogecoin pools have fixed contracts. The world of crypto can change very quickly. You could be stuck with an unprofitable contract for two years!
  • It’s no fun letting someone else do the mining for you!

Now you know about all the different ways to mine Dogecoin we can ask the big question, can you make tons of money mining Dogecoin?

So, Is Dogecoin Mining Profitable?

The short answer is, not really. Dogecoin mining is not going to make you a crypto billionaire overnight. One Dogecoin is worth about 0.05 US Dollars.

If you choose to mine Dogecoin solo, it will be difficult to make a profit. You will probably spend more money on electricity and hardware than you will make from Dogecoin mining. Even if you choose a Dogecoin pool or a cloud pool your profits will be small.

However, if you think I am telling you to not mine Dogecoin, then you’re WRONG! Of course, I think you should mine Dogecoin, however, there are simply better ways to make money with DOGE. One of the best options is to start trading. If you decide to do that it’s recommended to choose reliable crypto exchanges, such as Binance.

Make sure not to keep your cryptocurrencies in an online wallet, choose secure wallets instead. Such options include Ledger Nano X and Trezor Model T

But why? Seriously…

Well, you should mine Dogecoin because it’s fun and you want to be a part of the Dogecoin family. Cryptocurrency is going to change the world and you want to be part of that change, right? Mining Dogecoin is a great way to get involved.

Dogecoin is the coin that puts a smile on people’s faces. By mining Dogecoin you’ll be supporting all the good work its community does. You’ll learn about mining from the friendliest gang in crypto. And who knows? In a few years, the Dogecoin you mine now could be worth thousands or even millions! In 2010, Bitcoin was worthless. Think about that!

Only you can choose whether to mine Dogecoin or not. You now know everything you need to know to make your choice. The future is here. So, what are you going to do?