About the series: In [📚 in 🏎️] I will try to summarize in super dense notes the gist of a whole book. This is intended as a sneak peak for readers that have not yet read the book and for a reminder trigger for people who did. Enjoy! (P.S. I have links to longer book summaries/reviews at the end of the post.)

This book is about practical tips on how to create a good impression on people and influence them to agree with you. You probably already doing some of these techniques but it’s great to have these all in one place. The author gives multiple examples of how these principles might apply in real life. Here I am listing the book content table along with the one-line principle. Also, I bold-ify what I consider to be the most important principles.

Fundamental techniques in handling people

1. ‘If you want to gather honey, don’t kick over the beehive’
   → Don’t criticize, condemn or complain.
2. The big secret of dealing with people
   → Give honest and sincere appreciation.
3. ‘He who can do this has the whole world with him. He cannot walks a lonely way’
   → Arouse in the other person an eager want.

Six ways to make people like you

1. Do this and you’ll be welcome anywhere
   → Become genuinely interested in other people.
2. A simple way to make a good first impression
   → Smile.
3. If you don’t do this you are headed for trouble
   → Remember that a person’s name is to that person the sweetest and most important sound in any language.
4. An easy way to become a good conversationalist
   → Be a good listener. Encourage others to talk about themselves.
5. How to interest people
   → Talk in terms of the other person’s interests.
6. How to make people like you instantly
   → Make the other person feel important — and do it sincerely.

How to win people in your way of thinking

1. You can’t win an argument
   → The only way to get the best of an argument is to avoid it.
2. A sure way of making enemies and how to avoid it
   → Show respect for the other person’s opinions. Never say, “You’re wrong.”
3. If you wrong, admit it
   → If you are wrong, admit it quickly and emphatically.
4. A drop of honey
   → Begin in a friendly way.
5. The secret of Socrates
   → Get the other person saying “yes, yes” immediately.
6. The safety valve in handling complains
   → Let the other person do a great deal of the talking.
7. How to get cooperation
   → Let the other person feel that the idea is his or hers.
8. A formula that will work wonders for you
   → Try honestly to see things from the other person’s point of view.
9. What everybody wants
   → Be sympathetic with the other person’s ideas and desires.
10. An appeal that everybody likes
    → Appeal to the nobler motives.
11. The movies do it, TV does it, Why don’t you do it?
    → Dramatize your ideas.
12. When nothing else works, try this
    → Throw down a challenge.

Be a leader: How to change people without giving offense or arousing resentment

1. If you must find fault, this is the way to begin
   → Begin with praise and honest appreciation.
2. How to criticize — and not be hated for it
   → Call attention to people’s mistakes indirectly.
3. Talk about your own mistakes first
   → Talk about your own mistakes before criticizing the other person.
4. No one likes to take orders
   → Ask questions instead of giving direct orders.
5. Let the other person save face
6. How to spur people on to success
   → Praise the slightest improvement and praise every improvement. Be “hearty in your approbation and lavish in your praise.”
7. Give a dog a good name
   → Give the other person a fine reputation to live up to.
8. Make the fault seem easy to correct
   → Use encouragement. Make the fault seem easy to correct.
9. Making people glad to do what you want
   → Make the other person happy about doing the thing you suggest.

Longer book reviews/summaries: 1, 2, 3, 4

[book review] [📚 in 🏎]: How to win friends and influence people was originally published in Rock and Null on Medium, where people are continuing the conversation by highlighting and responding to this story.

Blockchain is hot right now. And you know what’s hotter? Ethereum. I have recently experimented with Ethereum by making a simple DApp (Distributed App). I want to contribute back to the community …… by making another (kind of) tutorial on how to create a DApp.

The objective of this post will not be to guide you step-by-step on how to build a DApp. I won’t explain everything here; I will link to a lot of other places that explain each part better. Still, I believe it’s good high-level overview on how / what is needed to start building Ethereum DApps.

Glossary

If you want to get a high-level understanding of what blockchain is, dedicate 15 minutes and watch these excellent videos (it’s part 1 & 2, and then you can play practically with the introduced concepts).

Ethereum is a “blockchain-based distributed computing platform” that allows you to create distributed programs called smart contracts. Now, if you make this contract to act like the back-end of a website, and you put a front-end to interact with this contract you get a DApp (distributed app).

These contracts are written in a language called Solidity that has a C-like syntax (although you can write smart contracts in other languages, this is the most popular). To actually use these smart contracts, you need to deploy them to the Ethereum network by paying some Ether, the native cryptocurrency of Ethereum.

Intro

You used to have to manually keep track of where you deployed a contract, but new frameworks like Truffle and Embark are making developing and deploying smart contracts way easier.

To create my sample DApp I used the Truffle framework because it seems to be more popular (i.e. more StackOverflow posts) and had better tutorials available. Embark seems really decent, but being a complete newbie in the field, I went with the popular choice.

My sample DApp is called dWIP (decentralised work in progress) and you can use it to publicly keep track on the work you are doing for your side-project (partly inspired by wip.chat). As shown in the GIF, you just enter the task you are working on and it’s added to the list. Then you can share this page with the users of your side-project to keep them updated about the progress :)

Truffle provides the Ethereum Pet Shop tutorial which I highly recommend and I based my sample DApp on.

Backend

As mentioned earlier, the backend of this web app is the smart contract. To get a taste of Solidity, this how the contract for my sample dapp looks like:

pragma solidity ^0.4.6;  // 1.

contract Dwip {

    struct Task {
        string text;
        uint timestamp;
    }

    struct AddressData {  // 2.
        Task[] taskArray;
        string addressName;
    }

    mapping(address => AddressData) addressDataMap;  // 3.

    function appendTask(string taskText) public returns (uint length) {  // 4.
        Task memory t = Task(taskText, block.timestamp);
        return addressDataMap[msg.sender].taskArray.push(t);
    }

    function getTaskCountAddr(address addr) public constant returns (uint length) {  // 5.
        return addressDataMap[addr].taskArray.length;
    }

    function getTaskCount() public constant returns (uint length) {
        return getTaskCountAddr(msg.sender);
    }

    function getTaskAtIndexAddr(address addr, uint index) public constant returns (string value) {  // 6.
        return addressDataMap[addr].taskArray[index].text;
    }

    function getTaskAtIndex(uint index) public constant returns (string value) {
        return getTaskAtIndexAddr(msg.sender, index);
    }

1. Instruction for the Solidity compiler denoting the language version
2. The data that we hold for each address. A different address should be used in this case for every different side-project
3. The mapping from address to the data we hold.
4. Create a new WIP task (i.e. a new row) calling this function. Notice that the function return type is declared at the end.
5. Get how many WIP tasks (i.e. rows) are stored for a specific address. Notice the constant keyword that indicates that the function does not make any changes to storage (i.e. saving data). It’s just read-only (and cheaper to call).
6. There are 2 versions for each function, one that uses the msg.sender address and one that takes the address as a parameter. This for linking to different address (i.e. side-projects) with a GET parameter (e.g. /dwip?addrr=0xABCD)

(To write a contract and be able to iterate and interact with it, you can use Remix, the official online Ethereum IDE.)

Truffle provides an easy way to write tests in Solidity to call these methods and verify that they work as indented (and that will not break in the future).

pragma solidity ^0.4.17;

import "truffle/Assert.sol";
import "truffle/DeployedAddresses.sol";
import "../contracts/Dwip.sol";

contract TestDwip {
  Dwip dwip = Dwip(DeployedAddresses.Dwip());

  function testAppendTask() public {
    uint returnedLength = dwip.appendTask("hello");

    Assert.equal(returnedLength, 1, "Incorrect task length.");
  }

  function testGetCount() public {
    uint returnedCount = dwip.getTaskCount();

    Assert.equal(returnedCount, 1, "Incorrect task count.");
  }

  function testGetCountAddr() public {
    uint returnedCount = dwip.getTaskCountAddr(this);

    Assert.equal(returnedCount, 1, "Incorrect task count.");
  }

  function testGetTaskAtIndex() public {
    string memory expected = "world";
    dwip.appendTask(expected);
    string memory returnedTask = dwip.getTaskAtIndex(1);

    Assert.equal(returnedTask, expected, "Incorrect task text.");
  }

  function testGetTaskAtIndexAddr() public {
    string memory expected = "beyond";
    dwip.appendTask(expected);
    string memory returnedTask = dwip.getTaskAtIndexAddr(this, 2);

    Assert.equal(returnedTask, expected, "Incorrect task text.");
  }
}

These are not the traditional unit tests in the sense that the state is not reset every time. To actually run these test, you can use a local private blockchain with Ganache:

Frontend

When you are done writing the contract, you will have to call these methods. The frontend of a DApp consists of conventional web technology (i.e. javascipt, html, css). When you deploy a contract on a network (main or test network), you get an address to be able to call it. Truffle makes it really easy to call a smart contract by keeping track of where (i.e. the address) is deployed. For instance, for my sample DApp the code to add a new WIP task is similar to:

web3.eth.getAccounts(function (error, accounts) {  // 1.

    var account = accounts[0];  // 2.

    App.contracts.Dwip.deployed().then(function (instance) {  // 3.

        return adoptionInstance.appendTask(taskText, {from:          account});  // 4.

    }).then(function (result) {
        return App.fetchWips();  // 5.
    }).catch(function (err) {
        console.log(err.message);
    });
});

1. Web3 is the javascript library to communicate with Ethereum nodes.
2. Select the first available account from the wallet.
3. Truffle is keeping track of the address the contract is given when deployed on a network.
4. When you have an instance of the deployed contract, you can call methods. Note that the method called here is not constant so an account to be charged is provided as an argument.
5. The result of the method call is returned. Here is unused.

Wallet

To make a transaction with an Ethereum smart contract you need a wallet. DApps are just smart-contracts-as-web-backends and an in-browser wallet is needed to perform transactions. The most popular (and the only one I know) in-browser wallet is called Metamask for Chrome, Firefox and Opera. Extensive instructions here on how to set it up.

Backend deployment

When you want to make your DApp available for the world, you need to deploy it to the Ethereum main net or a test net. Like the names are suggesting, to deploy to the main net real ether (i.e. money) is needed. I have only tried deploying to a test net (there are multiple test nets, like Rinkeby and Ropsten) where no real money is needed (you get fake money from a faucet). To deploy to a network you will need to run a client on your machine and download the whole blockchain transaction history on your machine (that means you will need a lot of space, and depending on your connection a lot of time). To deploy to Rinkeby follow the instructions here. Note that there is a way to deploy without downloading the whole blockchain on your machine, but I have not tried it.

Frontend deployment

You can deploy the frontend (i.e. HTML, CSS, Javascript files) to a regular web server (like I did) or go fully decentralised and host your files on a P2P network like IPFS. Follow the instructions in the “Deploy the application online with IPFS” section for IPFS hosting.

Conclusion

Blockchain and the decentralised web revolution in general, is exciting and it evolves really fast. New frameworks, like Truffle, removes the major pain points from Ethereum development, but it’s still early so keep an eye (as I will do) for further developments in the field!

A glimpse into how to build an Ethereum DApp was originally published in Rock and Null on Medium, where people are continuing the conversation by highlighting and responding to this story.

About the series: In [📚 in 🏎️] I will try to summarize in super dense notes the gist of a whole book. This is intended as a sneak peak for readers that have not yet read the book and for a reminder trigger for people who did. Enjoy! (P.S. I have links to longer book summaries/reviews at the end of the post.)

The author believes that most startups fail, not because of a bad product, but because they fail to attract enough customers. Most startups spend all their resources on engineering and building a great product without paying any attention to getting traction. After they build the product, then they seek to get traction which is too late due to exhausted resources.

The book introduces the following rules:

50/50 rule

Spend 50% on product development and 50%on marketing/traction from the beginning. This is useful for getting feedback for the product from day 1 that will help refine the product along the way. The author suggest that a product is like a leaking bucket that as time goes by and you fill the holes more and more customers will stick around.

Bullseye Framework

At each stage of a startup a different traction channel (will list them later) is suitable for “moving the needle”. There is no way to predict which one is the correct, so test and decide:

1. Brainstorm ideas for traction channels
2. Run cheap tests for the best brainstorm ideas
3. Focus all your resources on the one most successful test
4. Repeat

Critical path

The most common mistake for a startup is to spend the limited available resources on non-essential stuff. Set a quantifiable traction goal and do not get distracted.

Available traction channels

The book has a good summary on the following traction channel with a practical tips and testimonials on how to utilize them.

• Targeting blogs
• Traditional publicity (e.g. magazines, TV, etc)
• Unconventional PR (e.g. publicity stunt)
• Search Engine Marketing (SEM)
• Social and Display Ads
• Offline ads
• Search Engine Optimization (SEO)
• Content marketing
• Email marketing
• Viral marketing
• Engineering as marketing
• Business Development (BD)
• Sales
• Affiliate programs
• Existing platforms
• Trade shows
• Offline events
• Speaking engagement
• Community building

Longer book reviews/summaries: 1, 2, 3, 4

[book review] [📚 in 🏎]: Traction: How Any Startup Can Achieve Explosive Customer Growth was originally published in Rock and Null on Medium, where people are continuing the conversation by highlighting and responding to this story.

About the series: In [📚 in 🏎️] I will try to summarize in super dense notes the gist of a whole book. This is intended as a sneak peak for readers that have not yet read the book and for a reminder trigger for people who did. Enjoy! (P.S. I have links to longer book summaries/reviews at the end of the post.)

The author identified 7 weapons of influence that discovered over his career in Psychology. He justifies each and every one of them with multiple examples to illustrate how these rules are working and can be observed in everyday life.

The weapons/rules of influence:

• Contrast principle
  Showing the expensive product first, before showing a cheaper product makes it more attractive because there is an implicit comparison.
• Reciprocation
  Giving a small gift to someone (without asking for something back), might lead to a bigger return later because people don’t like to be indebted.
• Commitment and Consistency
  People tend to remain compliant to their commitments, once they made them. Having someone commiting to something small/hypothetical before asking for something bigger but related to the commitment will increase the chance of compliance.
• Social Proof
  Especially in unknown situations, people are influenced with what other people do. This is exploited in everyday life (e.g. putting people in bars just to make them look popular, tip-jar that is pre-filled with money to show that other people already donated, etc).
• Liking
  We tend to comply more when we the compliance request comes from someone we like. We like people similar to us, attractive people, people that compliment us, etc.
• Authority
  Authority affects how we interact and perceive people. The higher the authority, the more cautious we are in our conversation and more likely to comply with no questions asked.
• Scarcity
  People tend to appreciate more something that might lose than something that might win. This is be exploited in auctions, phrasing of offers (e.g. “You are losing $50 per month ….”), etc.

Longer book reviews/summaries: 1, 2, 3

[book review] [📚 in 🏎️]: Influence - The Psychology of Persuasion was originally published in Rock and Null on Medium, where people are continuing the conversation by highlighting and responding to this story.

We’ve moved to our own blog :) Read from there!

Intro

Continuous Integration (CI) is the process of automating the build and testing of code every time a team member commits changes to version control.

CI brings benefits for every team, from one-(hu)man-teams to big teams, by detecting integration errors as quickly as possible. Individual developers can ensure that the “minor change” they submit without hitting “Run” in Android Studio doesn’t break anything and big teams contributors can ensure that the feature they worked in isolation for the last week doesn’t introduce a regression.

Atlassian’s Bitbucket is a great version control hosting provider for indie developers, offering not only unlimited private Git repositories but also free (limited amount) CI/CD using their Pipelines feature! I have been using Bitbucket for microtasks project but never bothered with setting up CI because I considered it too hard. As it turns out, it’s a 1-minute setup!

1-minute setup

All the credit goes to Ming C from this StackOverflow post. And it’s just 2 easy steps (actually the “1 minute” estimation might be an overestimation if everything goes right :)

Select Pipelines in Bitbucket

From the side navigation bar in your Bitbucket project, select Pipelines and then Java (not really necessary, it’s just pre-filling the editor).

Commit the Pipeline configuration

In the online editor, fill the content of bitbucker-pipelines.yml:

image: mingc/android-build-box:latest

pipelines:
  default:
    - step:
        script:
          - chmod +x gradlew
          - ./gradlew assembleDebug

Commit and that’s all! Now everytime you commit to the main branch, assembleDebug Gradle task will be executed to verify that the app builds just fine. To run your unit tests instead of just building, replace assembleDebug with test.

(Optionally) Going deeper

Brief Pipelines explanation

Pipelines are basically running a Docker image and then execute the commands in the scripts section. The android-build-box image I think contains everything (SDK 16–26, Support Library, Play Services, etc) that a typical modern Android app might need (and more). For more specific needs, you will need to build your own Docker image.

Gradle task(s)

You can select to run more than one Gradle task from your Android project by appending more lines to the scripts section (to see all Gradle tasks from Android Studio, View -> Tool Windows -> Gradle). A real CI system will run tests to ensure that a new commit does not introduce a regression (i.e. re-introduce an old bug). Be cautious of the time limit the free Bitbucket plan provides, 50 minutes per month. Running too many tasks/tests might consume this limit pretty quickly.

Periodic integration

You can also configure the Pipeline to run periodically, like every hour/day/week. If you have a bigger project with multiple contributors, this is probably needed. Just select Schedules button from the Pipelines view in Bitbucket.

Local Pipelines debug

At some point, something in the Docker image, Pipelines, or your project will stop working and you might need to emulate what Pipelines are doing locally to debug the issue. To do this follow the instructions in Bitbucket website, or for this specific image:

1. Get Docker and download the android-build-box image (Warning: It’s a ~5GB image):

docker pull mingc/android-build-box:latest

2. Get an interactive shell into the Docker image, with the same restrictions (i.e. RAM, swap memory, etc):

docker run -it --volume=/PATH/TO/YOUR/SRC:/localDebugRepo --workdir="/localDebugRepo" --memory=4g --memory-swap=4g --memory-swappiness=0 --entrypoint=/bin/bash mingc/android-build-box:latest

3. Run the commands in the scripts section and debug the issue(s).

Conclusion

I think that CI is extremely useful for detecting issues early on and since it’s that easy (and free) to set it up, everyone using Bitbucket for version control should have it enabled!

P.S. If you are like me and enjoy being productive throughout the day, check out microtasks, a task-as-undismissable-notification manager that helps you remember the small things that matter :)

Setup Android Continuous Integration (CI) for Bitbucket in 1 minute. was originally published in Rock and Null on Medium, where people are continuing the conversation by highlighting and responding to this story.

Recently, after all this time listening and reading about Kotlin I decided that it was time to give it a try. The best way to do it, I thought, was to write a new Android app from the beginning. Sure, Kotlin was designed to be “multi-platform” from the beginning (JVM, Server, JS, Native) but currently, it shines in the Android dev world.

The only issue was that since my last involvement with Android the new Android Architecture Components (AAC) had been introduced by Google and I didn’t have the chance to give them a try either.

Now, I had 2 new shiny things to try out and to be honest it seemed to be a bit overwhelming at first. If you are in a similar position, I urge you to fear not. These are not just “shiny things” but will actually make you more productive if you have them in your toolkit.

I will not repeat what you might have already read/heard about the merits of Kotlin. I will try to guide you through AAC using Kotlin and explain as much Kotlin features/syntax as possible in the way. I don’t expect to fully understand Kotlin or AAC by the end of this post, but you will have a taste of what Kotlin and AAC are so when you have the time to take a deeper look.

Stick to the end that I have some useful links for diving deeper into Kotlin and AAC.

Lifecycle

The Android System can destroy and recreate an app’s components (e.g. Activity, Fragment) due to memory constraints (e.g. low on RAM) or configuration changes (e.g. switch from Portrait -> Landscape). You might know that Android components have complicated life cycles. Each component has its own different lifecycle (e.g. fragments, activities) and this makes things even more complicated to reason about.

These complicated lifecycles make lives of developers difficult because you might start an operation on an Activity (e.g. network request) and while in progress the Activity can be destroyed and another will be recreated. You will need to show the results of the operation in the new Activity. AAC introduced components (i.e. Activities, Fragments) that are Lifecycle aware. This makes it easier to reason about and not having to manually keep track in which lifecycle state each component is.

LiveData

This provides an async mechanism to provide data changes using the Observer pattern. It’s a very similar, yet way simplified version, of the popular and very powerful RxJava. The big difference is that LiveData is respecting the Lifecycle of the Android component that is attached to and delivers data changes only when the component is in “active” state (e.g. when the activity is stopped/destroyed will not try to deliver changes). This avoids memory leaks, crashes due to stopped activities and other issues. Too much talk, let’s see a code example:

private val username = MutableLiveData<String>()

/* Called on app launch */
fun initNetworkRequest() {
    /* expensive operation, e.g. network request */
    username.value = "Peter"
}

fun getUsername(): LiveData<String> {
    return username
}

// --------------------------------------------------------

/* Called on Activity creation */
getUsername().observe(this, Observer { user -> Log.d(TAG, user) })

With this approach, even if the Activity is destroyed by the system and another one is created before the request finishes, the correct one will observe and show the results.

Kotlin

private val username = MutableLiveData<String>()

• New instances are constructed without the new keyword, just their class name.
• val means final. This variable cannot be reassigned.
• var for a variable that can be reassigned.
• Kotlin is strongly typed, i.e. each variable has an explicit type. If it can be inferred then you can avoid writing it, like in this case. Otherwise, you can also write:
  val username: MutableLiveData<String> = MutableLiveData<String>
• Visibility modifier private means the same thing as in Java, only visible within this class. Most of the other modifiers are the same. The default visibility, if there is no modifier specified, is public.

fun getUsername(): LiveData<String> {

• Use fun keyword for method declaration.
• The return type comes at the end of the signature.
• There is no void in Kotlin (it’s Unit), just omit the type to return nothing like in:
  fun initNetworkRequest()

username.value = "Peter"

• Kotlin is smart enough to convert Java getValue/setValue to properties like this (i.e. when running this code you are calling username.setValue() behind the scenes).

getUsername().observe(this, Observer { user -> Log.d(TAG, user) })

• Here an anonymous Observer class is used and Kotlin is automatically doing the work of figuring out which method to override (take a look at the Java code to help you understand what Kotlin is doing).

ViewModel

The ViewModel is used to persist configuration changes (i.e. Portrait -> Landscape). You can save the logical state of the UI in the ViewModel and decouple it from the Android component (i.e. Activity, Fragment) that can be destroyed at any time. If we combine the previous code with this one:

class MainViewModel : ViewModel() {

    private val username = MutableLiveData<String>()

    fun initNetworkRequest() {
        /* expensive operation, e.g. network request */
        username.value = "Peter"
    }

    fun getUsername(): LiveData<String> {
        return username
    }
}

// --------------------------------------------------------

/* Called on Activity onCreate() */
viewModel = ViewModelProviders.of(this).get(MainViewModel::class.java)
getUsername().observe(this, Observer { text -> Log.d(TAG, text) })

/*  Called if there is no active network request */
viewModel.initNetworkRequest()

No matter how many times the Activity will be destroyed and recreated, the same ViewModel instance will be used. Take a look at the ViewModel lifecycle. Therefore, you can safely store the state of your UI and on recreation the new Activity will get the latest values.

Room

Room library provides an easy way to convert objects to data stored in a local SQLite database on the device. This is useful for persisting data across different app sessions and also for offline usage. Room has 3 main components that you need to define to use it:

@Entity
data class User(
    @PrimaryKey(autoGenerate = true) val id: Int? = null,
    @ColumnInfo(name = "username") val username: String) {
}

This class describes the data format (and how the underline SQL table is defined). This is what you will fill in order to save a new row in the database and how the data that are retrieved from the database will be returned to you.

@Dao
interface UserDao {

    @Query("SELECT * FROM user")
    fun all(): List<User>

    @Insert
    fun insertAll(users: List<User>): List<User>

    @Insert
    fun insert(user: User): Long

    @Update
    fun update(user: User)

    @Delete
    fun delete(user: User)
}

The Data Access Object defines how you access your data. Notice that this is just an interface with some annotated methods. Room will create the implementations based on what you provide in the annotated methods.

@Database(entities = arrayOf(User::class), version = 1)
abstract class Database : RoomDatabase() {

    companion object {

        private val DB_NAME = "UsersDatabase"

        @Volatile private var INSTANCE: Database? = null

        fun getInstance(context: Context): Database =
                INSTANCE ?: synchronized(this) {
                    INSTANCE ?: buildDatabase(context).also                     
                        { INSTANCE = it }
                }

        private fun buildDatabase(context: Context) =
                Room.databaseBuilder(context.applicationContext,
                        Database::class.java, DB_NAME)
                        .build()
    }
}

This the main access point for the database. It looks complicated because it was taken from a sample app from Google, but I find it more robust than the one provided the docs.

Kotlin

data class User(val id: Int? = null, val username: String)

• data keyword is used for value classes that their aim is just to hold data. All the methods such equals()/hashCode()/toString()/copy() are created automatically.
• Using the variables after the class name you declare them as (public) member variables. Since val is used these are immutable member variables.
• Int? means that this variable is allowed to take null as its value. Without ‘?’ at the end of the variable type, null is not allowed.

companion object { 

• This is similar to Java static. Of course, there are differences, such as that you can pass this object around and it can implement interfaces.

INSTANCE ?: synchronized(this) {

• The ?: operator can be used to return a value if it’s not null, otherwise to return what is right of the operator. It replaces all the null-safe if statements in Java.

Afterword / Further reading

In case you are curious, the app I created is microtasks and I would be delighted to try it and give feedback (using the in-app “Send feedback” option :). Also, if you are looking to promote your apps using promo codes take a look at Promies!

For Kotlin, I had great fun using Kotlin Koans (available in-browser as well!) to learn the syntax and features interactively. Also, as a cheatsheet, I used the Learn X in Y minutes. Kotlin is a modern language with a lot of features. I did learn the basics but there are so many advanced features that I will be in learning mode for a while.

For Android Architecture Components, I relied mainly on the official documentation. I found it easy to follow and with good examples. Also, I found this Guide to App Architecture to be really good at giving you a high-level overview on how to structure your app.

I hope you found this useful! Happy coding using Kotlin and AAC! :)

P.S. If you are like me and enjoy being productive throughout the day, check out microtasks, a task-as-undismissable-notification manager that helps you remember the small things that matter :)

Exploring Kotlin using Android Architecture Components (and vice versa) was originally published in Rock and Null on Medium, where people are continuing the conversation by highlighting and responding to this story.

You’ve probably heard that you need to split the time working on your project 50/50 on development and traction/promotion. If you are like me, you’ve probably never done it.

Because it’s hard. I mean, you know that Google, Facebook, and others are offering ads that you can purchase to promote your app. You know that there are forums, communities and other places that you can post. But the most important part is that you are not just aiming for the people that see the post. You are aiming for people to find your app and then spread it. But, what should you write to those ads? What is the right content for the post in the forum to accomplish this mythical “viral post”? I don’t have the answer yet but I think that I have some guidelines after reading “Contagious: How to Build Word of Mouth in the Digital Age”. If you enjoy this post, I strongly advise you to go and read the full book since I only talk about some of the principles that I find most important in my case.

Triggers

How many times you’ve thought of “having a break” and the KitKat’s slogan of “have a break, have a KitKat” jumped into your head? It happens to me all the time. Also, it happens to everyone else and most of the times not even consciously. If you choose your wording carefully, you can hopefully associate an everyday trigger with your app to make it come to mind more often.

Practical value

Does your app have a practical value that can help people solve a problem? If yes, talk directly about it with the aim to package your knowledge into a shareable bit that people can spread when they or someone they know face the problem you are solving. Do not fall into the typical mistake of over-decorating your description to the point that no one understands what you are actually doing.

Emotion

If your product does not have a strong practical value, make sure that your post, ad or video emits emotion. Nowadays, creating a video promo for your app/game is quite common. If after viewing your video the users have shed a tear, for instance, is highly probable that they are going to share it forward. Emotional posts, and not necessarily posts that emit positive emotions (anger is quite shareable), tend to make people share things more.

Stories

In case you have a lot of real-estate to write, e.g. in a forum post, you can use a story to embed your message. Nothing is more shareable than a good story to tell your friends. But do not forget that your app/game must be a crucial part of the story, not just a detail or a “secondary character”. Otherwise, the story might be shared but without the details. I believe this is the hardest guideline to follow, but still, there are some cases that might apply.

Various useful tips

• Exclusivity: People love to feel special. It might be counter-intuitive but in some cases restricting access to your product (e.g. waitlist, refer only) might bring more traction.
• Strike-through sales: When seeing a strike-through price you automatically compare the price to the original. So having a significant (but reasonable) higher price as the original might make your offering look like a better deal.

Conclusion

This is by no means a complete list of what is offered in the book. If you enjoyed what you’ve read you should definitely take a look at the book. Nevertheless, I hope that these short guidelines will help you write those posts that will become viral, or at least more shareable.

[book review] The mythical “viral post”. was originally published in Rock and Null on Medium, where people are continuing the conversation by highlighting and responding to this story.

I did some artificial intelligence (AI) courses while I was studying but I never did anything outside the classroom. Machine learning (ML), and AI in general is the most trending subject in the tech scene right now.

And for a good reason. We are in the “democratizing” era of AI. Tools are being developed and popularized that are aimed to be used by everyone, not just the small academic community. If you want an introduction to the inner workings of Machine Learning and get an intuition on how things work, I cannot recommend enough the Machine Learning course by Andrew Ng. I will try to explain some basic theory here, but I am just exploring/learning, so follow with caution :)

A bit of theory

Artificial Intelligence (AI) is a “superset” of Machine Learning (ML) and Neural Networks (NN) is a computational model used in ML. NN is a Supervised Learning technique which means that a dataset with multiple examples with the “right answers” is needed for the model to “learn”. To get to the NN, we have to define some more stuff along the way.

Linear Regression

A regression problem means we have to predict a real-valued output. For example, let’s use the (typical) house pricing example where we only have 1 characteristic (feature), the area of the house, and we want to predict the house price. Given a set of area(X)/house-price(Y) pairs (dataset) we can plot the following graph (where each orange dot is an area/house-price pair):

From basic linear algebra we know that the equation of the line is in the form Y = θ0 + θ1*X. This is called the hypothesis and what we are looking for are the values for θ0 and θ1 (called the parameters). If we find a good set of θ0, θ1 then we will be able to predict a house price given the area of any house. To do that, first we need to define the error/cost which is the difference of our hypothesis from the actual value:

There are many ways to calculate the cost function with one of the most popular to be the mean squared error. Then all we need to do is to start from a (most of the times random) initial assignment of θ0, θ1 and using an iterative optimization algorithm (like Gradient Descent) to minimize the cost of our hypothesis by iterating over our dataset.

Logistic Regression

But what if we do not want a real-valued output and we would like a probability? We can use Logistic Regression where the hypothesis outputs real-valued numbers from 0 to 1. To do that we can use the Sigmoid function to map any real-valued number of our hypothesis to the (0, 1) interval:

We can then adapt the cost function and use the same optimization algorithms to find a hypothesis that minimizes the cost.

Neural Networks

But most of the real world problems are not linearly separable. It turns out that connecting small units that do logistic regression between them is one of the most computationally efficient ways to compute non-linear hypothesis:

Every node in the graph, except from input layer, represents simple logistic regression with inputs the incoming edges and outputs the outcoming edges. The rightmost node, the output layer, will give us a final probability given the input characteristics (features).

Common problems and validation set

The two most common problems are underfitting and overfitting (with the latter to be more popular). Underfitting occurs when your hypothesis does not fit the data well enough, overfitting occurs when the hypothesis is too closely fit the training dataset and does not generalize well to new unseen data. To evaluate our model, we split our dataset into the training and validation set. Then we use the training set to fit our model and test it with the unseen validation set.

TensorFlow + Keras

If you are following any tech news site, you’ve probably heard of TensorFlow. It’s Google’s machine learning framework that was open-sourced in 2015 and met with huge success from the open-source community. Unfortunately, the framework although powerful is highly technical and difficult to use by a data analyst/machine learning “outsider”. This is where Keras comes in, a higher level (= user friendlier) layer on top of TensorFlow (and other ML frameworks) that allows you to make ML and more specifically Neural Networks (NN) faster and easier.

Setup

I used the Anaconda Python distribution and found the setup of the development environment relatively easy. After installing Anaconda for your platform (you can also try Minicoda for a lighter version if you are short on space), CD to the bin directory of the distribution and run (Linux & MacOS):

./pip install tensorflow
./pip install keras
./pip install pandas

That’s it, if everything works fine, you are all set. You can try the excellent PyCharm Community Edition if you are a fan of the JetBrains’ family of IDEs.

Learn Python

“But I don’t know python!” I hear you saying. Neither did I. I just learned the basics and I keep learning. For my introduction to the language, I used the interactive PyCharm Edu which is a desktop app with an IDE and a Python interpreter with the only aim in life to educate you about Python. The basic tutorial consists of a set of unit tests that you have to complete a small part for them to run successfully. I found Python in general to be a very pleasant to use language.

The dataset

Let’s start with the actual script. I used the “Medical Appointments No Show” from Kaggle as my dataset for this experiment. This is a dataset that contains 300k medical appointments with characteristics (features) of the patients and whether the patient showed up in the appointment or not. We will try to create a Neural Network that given the characteristics of a patient will predict the probability of that patient showing up.

Preprocess the dataset

The first step is to prepare our data before training our model. We read our data and separate them into X and Y; X are the patient’s characteristics (features) and Y is whether the patient shows up or not. Use the following to have a glimpse at the structure of our dataset:

import pandas as pds

dataframeX = pds.read_csv('No-show-Issue-Comma-300k.csv', usecols=[0, 1, 4, 6, 7, 8, 9, 10, 11, 12, 13])
dataframeY = pds.read_csv('No-show-Issue-Comma-300k.csv', usecols=[5])

print(dataframeX.head())
print(dataframeY.head())

As you can see, some of the features are not represented as numeric values. We can change this using the powerful Pandas library:

def weekdayToInt(weekday):
    return {
        'Monday': 0,
        'Tuesday': 1,
        'Wednesday': 2,
        'Thursday': 3,
        'Friday': 4,
        'Saturday': 5,
        'Sunday': 6
    }[weekday]

def genderToInt(gender):
    if gender == 'M':
        return 0
    else:
        return 1

def statusToInt(status):
    if status == 'Show-Up':
        return 1
    else:
        return 0

dataframeX.DayOfTheWeek = dataframeX.DayOfTheWeek.apply(weekdayToInt)
dataframeX.Gender = dataframeX.Gender.apply(genderToInt)
dataframeY.Status = dataframeY.Status.apply(statusToInt)

print(dataframeX.head())
print(dataframeY.head())

Now we have replaced the values for each feature with a unique numeric value. We do the same for the target dataframeY.

The Neural Network

Time to create our Neural Network. Creating and training a NN in Keras is really easy. You describe the model as sequential layers that data flow through. Then you feed it the dataset we prepared in the earlier section and train the model:

# 1
import numpy as np
seed = 7
np.random.seed(seed)

# 2
from keras.models import Sequential
from keras.layers import Dense
model = Sequential()
model.add(Dense(12, input_shape=(11,), init='uniform', activation='sigmoid'))
model.add(Dense(12, init='uniform', activation='sigmoid'))
model.add(Dense(12, init='uniform', activation='sigmoid'))
model.add(Dense(1, init='uniform', activation='sigmoid'))
model.summary()

# 3
import keras
tbCallBack = keras.callbacks.TensorBoard(log_dir='/tmp/keras_logs', write_graph=True)

# 4
model.compile(loss='mean_squared_error', optimizer='adam', metrics=['accuracy'])
model.fit(dataframeX.values, dataframeY.values, epochs=9, batch_size=50,  verbose=1, validation_split=0.3, callbacks=[tbCallBack])

Let’s take it step by step and I will do my best to explain concisely what is happening.

#1: We use a constant seed for our random number generator to create the same pseudo-random numbers each time. This comes handy when we want to try different models and to compare their performances.
#2: Define the NN as with fully connected layers with 12 nodes each that are using the sigmoid function.
#3: Needed to use the TensorBoard tool to visualize the model training.
#4: Train our model using the defined optimizer and loss function. Epoch is the number of times (iterations) the whole data set will go through the network, validation_split is how much data from the dataset to hold back just to validate the performance of the model.

We can now make predictions using our trained model using the model.predict() function.

TensorBoard

We can use the TensorBoard tool to visualize the training of our model by running the following inside the Anaconda bin folder (we defined the path in #3 of the previous section):

./tensorboard — logdir=’/tmp/keras_logs’

Conclusion

Machine Learning and Neural Networks are powerful and using TensorFlow+Keras can become fun as well. I have just scratched the surface of the subject in this post but I hope that I gave you a glimpse on what you can do with a few lines of code. I will keep learning about the subject and maybe come back with something more advanced (and useful)!

Playing with machine learning: An introduction using Keras + TensorFlow. was originally published in Rock and Null on Medium, where people are continuing the conversation by highlighting and responding to this story.

Definitions and advantages

You might have heard the term dependency injection before. You might have even tried to Google it and stumbled upon a definition that introduced 2 new unknown terms (inversion of control, dependency injection pattern). Personally, I find the following definition to be the most descriptive:

Dependency injection for five-year-olds:

When you go and get things out of the refrigerator for yourself, you can cause problems. You might leave the door open, you might get something Mommy or Daddy doesn’t want you to have. You might even be looking for something we don’t even have or which has expired.

What you should be doing is stating a need, "I need something to drink with lunch," and then we will make sure you have something when you sit down to eat.

- StackOverflow answer

In my own words, instead of being responsible for creating and providing all the dependencies an object needs, a magic “framework” takes this responsibility. This approach has many advantages, with the most important being:

• Since the framework is responsible for providing the dependencies, we can easily change an implementation of an abstraction without making a lot of changes.
• When testing, we can easily replace the real dependencies with fake/mock implementations.
• Dependency fulfilling for complex objects (i.e. objects that depend on objects that depend on other objects, multiple levels of dependencies) becomes easy since the framework takes care to figure it out.

Dagger 2

Dagger 2 is a popular dependency injection (DI) framework for Java and especially popular in Android. The main reason is that it generates all the required code and does not use any reflection, which is slow in general but especially heavy in mobile. This generate-all-the-code approach has the advantage that any mistake regarding the dependency graph will be caught during compile-time instead of run-time. The downside is that Dagger is considered less flexible than other DI frameworks out there, but the speed and compile-time safety that offers make up for its rigidness.

Concepts

Like every framework, Dagger has its own “vocabulary” that you need to learn in order to use it. If you used another DI framework before, you will surely find familiar terms.

Module

A class annotated with @Module that specifies what and how you provide a dependency. The what is defined by the return type of a @Provides annotated method. The method name does not matter.

The following example is fairly simple. Let’s suppose that MovieDbHelper is an interface and MovieDbHelperImpl is a respective concrete implementation. Every time some part of the app requests a MovieDbHelper, the provideMovieDbHelper() will execute and provide the dependency with an implementation of the requested interface.

@Module
class ApplicationModule {

    @Provides
    MovieDbHelper provideMovieDbHelper() {
        return new MovieDbHelperImpl();
    }
}

What if the MovieDbHelperImpl needed its own dependencies in order to be instantiated? Adding the dependencies as parameters in the provideMovieDbHelper(..) will make Dagger look for another @Provides method to fulfill the dependencies.

Creating Singletons is easy with Dagger; just annotate the @Provide annotated method with @Singleton to ensure that only a single instance will be returned when requested.

@Module
class ApplicationModule {

    private Context context;

    ApplicationModule(Context context) {
        this.context = context;
    }

    @Provides
    Context providesContext() {
        return context;
    }

    @Provides
    @Singleton
    MovieDbHelper provideMovieDbHelper(Context context) {
        return new MovieDbHelperImpl(context);
    }
}

Inject

A class can request its dependencies from the DI framework by annotating with @Inject its constructor, functions or member variables.

class MovieDbHelperImpl {

    @Inject
    MovieDbHelperImpl(Context context) {
        this.context = context;
    }

    [...]
}

Annotating a constructor with @Inject makes it discoverable to Dagger. After the above example, any other class that requests a MovieDbHelperImpl will get an instance, without requiring a @Provides method in a Module.

Constructor injection works fine for your own classes that you have total control over when to instantiate them. This is not the case for many Android specific objects such as Activities, Fragments, etc that are instantiated and provided by the system. In this case, you have to use injection of functions or member variables.

class SearchMoviesActivity extends AppCompatActivity {

    @Inject SearchMoviesPresenter presenter;

    [...]
}

class SearchMoviesActivity extends AppCompatActivity {

    SearchMoviesPresenter presenter;

    @Inject
    void onInject(SearchMoviesPresenter presenter) {
        this.presenter = presenter;
    }

    [...]
}

Component

Components are the glue between Modules and Injection targets. In other DI frameworks, you might find them with the name Injectors, which I find a more descriptive name for their functionality.

They are interfaces that are annotated with @Component and indicate which @Module(s) are including (i.e. which dependencies they know about and they can provide) and the injection targets that they can inject (i.e. the objects that request dependencies with the @Inject annotation).

@Component(modules = {ApplicationModule.class})
interface ApplicationComponent {

    void inject(SearchMoviesActivity searchMoviesActivity);

}

In order to actually use the Component to inject your injection targets (in the example above the SearchMoviesActivity), Dagger will generate an implementation of this interface prefixed with the word “Dagger” when your project is re-build. For example, to inject the dependencies requested by SearchMoviesActivity (using the @Inject annotated constructors/functions/variables) you need to create the component and inject the activity. If you have Modules that do not have a no-arguments constructor, you need to instantiate the module before creating the component.

public class SearchMoviesActivity extends AppCompatActivity {

    private ApplicationComponent applicationComponent;

    @Override
    public void onCreate() {
        super.onCreate();

        applicationComponent = DaggerApplicationComponent
                .builder()
                .applicationModule(
                   new ApplicationModule(getApplicationContext()))
                .build();
        
        applicationComponent.inject(this);
    }

    [...]
}

Scopes, Qualifiers, Subcomponents and more

This post covered just the tip of the iceberg; Dagger 2 has many more features to explore. Maybe I will try to cover them in a future post.

Simple sample setup

Instead of going on and overwhelm you with even more concepts, I will try to apply what are covered until now to show how you can use DI in a simple Android app. This is not an ideal setup, it’s using only a single component for the whole app but it can work for small apps. Ideally, you would want to have multiple components/subcomponents for each independent unit in your app.

Setup Dagger

Include the following lines in your app-level gradle file (app/build.gradle).

dependencies {
    compile "com.google.dagger:dagger:2.9"
    annotationProcessor "com.google.dagger:dagger-compiler:2.9"
    provided "javax.annotation:jsr250-api:1.0"
}

Application Module

A module that will provide the application context (and potentially other app-wide dependencies).

@Module
public class ApplicationModule {

    private Application app;

    public ApplicationModule(Application app) {
        this.app = app;
    }

    @Provides
    @Singleton
    Context providesContext() {
        return app;
    }

}

Application Component

The injector that needs to have a function for all the classes that can be injected. In this simple setup, you need to have an inject function for each Activity in the app.

@Component(modules = {ApplicationModule.class})
public interface ApplicationComponent {

    void inject(MainMenuActivity mainMenuActivity);
    
    void inject(PlayGameActivity playGameActivity);
}

Custom application
The single component that we have, will be instantiated and be accessible from here.

public class MyApplication extends Application {

    private ApplicationComponent applicationComponent;

    @Override
    public void onCreate() {
        super.onCreate();

        applicationComponent = DaggerApplicationComponent
                .builder()
                .applicationModule(
                   new ApplicationModule(getApplicationContext()))
                .build();
    }

    public ApplicationComponent getComponent() {
        return applicationComponent;
    }
}

Don’t forget that you need to modify the AndroidManifest.xml to declare you custom Application class.

<application
    android:name=".application.MyApplication"
    [...]

Base Activity

All the activities in the app will extend this base class that will provide (a kind of) a convenient way to inject each activity. In onCreate(..), it retrieves the component and calls the abstract method inject(..) that is implemented by each Activity.

public abstract class BaseActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        inject(((MyApplication) getApplication()).getComponent());
    }

    /**
     * Implement and call component.inject(this) for dependency
     * injection of this Activity.
     */
    protected abstract void inject(ApplicationComponent component);
}

Every activity

The activities have to call the super.onCreate(..) and implement the inject(..).

The Component needs to have an appropriate inject(..) function that takes as a parameter the current activity. Having only an injection method for the base class (e.g. inject(BaseActivity activity)) will not work.

public class MainMenuActivity extends BaseActivity {

    @Inject MainMenuPresenter presenter;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        [...]        
    });

    @Override
    protected void inject(ApplicationComponent component) {
        component.inject(this);
    }

    [...]
}

Every Presenter or another object that can be injected

Don’t forget that for Dagger to be able to know (and inject) an object, the constructor must be annotated with @Inject or it must be included in a Module.

public class MainMenuPresenter {

    @Inject
    MainMenuPresenter() {
       [...]
    }
}

Conclusion

This was just a taste of what dependency injection looks like and how it can be used in a very very simple Android app using Dagger 2. If you want to use it in a more complex app you should dig a little more and learn concepts such as Scopes and Subcomponents before using it in your app. Dagger 2 is a really powerful, efficient, and actively developed DI framework that I enjoyed working with. I hope you will enjoy learning and working with it as well!

P.S. If you are like me and enjoy being productive throughout the day, check out microtasks, a task-as-undismissable-notification manager that helps you remember the small things that matter :)

The lost droid and the magic Dagger: an intro to dependency injection for Android. was originally published in Rock and Null on Medium, where people are continuing the conversation by highlighting and responding to this story.

Alexa and the Amazon Echo, in general, seem to be a hot toy in (the tech) town. Recently, I got my hands on an Echo Dot (2nd edition) and I found it a great device, especially for listening to music. Nevertheless, I believe that its voice recognition capabilities (you might need to say things more than once) and its “intelligence” (it doesn’t seem to understand natural language very well) still need work. I might not be fully convinced yet that voice controlled devices will be the next big thing (in their current form) but that doesn’t mean that playing and developing on them is not fun.

In this post, I will attempt to guide you through the basics of how an Alexa skill (this is how “apps” are called) can be created using Java. I might not get deep into technical details or provide step-by-step instructions. My aim is to give you a higher level overview of how a skill works. You can get more technical by looking into the excellent samples repository that Amazon offers.

Skill description

Let’s say we want a skill that will be able to accept a specific movie genre and return back some movies matching this criterion. For each movie, you will be able to ask for more details like rating and/or plot. Cards that contain the spoken information will appear in the Alexa app at the same time. Let’s call this skill “Movie Genius”.

Basic skill lifetime

@Override
public SpeechletResponse onLaunch(LaunchRequest request, Session session) throws SpeechletException {
    [...]
}

This will be called if you launch your skill with no intent. For example saying “Alexa open Movie Genius” would call the above function.

@Override
public SpeechletResponse onIntent(IntentRequest request, Session session) throws SpeechletException {
    [...]
}

Every other time you interact with Alexa the above function will be called. For example, if you say “Alexa ask Movie Genius for a comedy” or when you respond to a question this will be called.

The building blocks

The intents

If most of the times the onIntent(..) is called, how do you distinguish between what the user wants each time? The skill can set a number of intents that supports in the Intent Schema (this is a text box in the Amazon Developer Console):

{
  "intents": [
    {
      "intent": "FirstResultIntent",
      "slots":[
        {
          "name": "genre",
          "type": "LIST_OF_MOVIE_GENRE"
        }
      ]
    },
    [...]
    {
      "intent": "AMAZON.HelpIntent"
    }
  ]
}

In this example there is 1 custom intent (FirstResultIntent) and 1 built-in intent (AMAZON.HelpIntent). The slots are a mechanism to pass additional parameters to the intent. For example in the phrase “Alexa ask Movie Genius for a comedy”, the “comedy” will be mapped to the “genre” slot. The LIST_OF_MOVIE_GENRE is just a list of possible values for the slot. Now, the onIntent(..) would look like this:

@Override
public SpeechletResponse onIntent(IntentRequest request, Session session) throws SpeechletException {
    Intent intent = request.getIntent();
    String intentName = (intent != null) ? intent.getName() : null;
    [...]
    if ("FirstResultIntent".equals(intentName)) {
        [...]
    }
    else if ("AMAZON.HelpIntent".equals(intentName)) {
        [...]
    } else {
        throw new SpeechletException("Invalid Intent");
    }
}

The speech sample

OK, and how do you map actual user’s speech to these intents? Using the Sample Utterances (again, this is a text box in the Amazon Developer Console).

FirstResultIntent I want a {genre}
FirstResultIntent find me {genre}
FirstResultIntent for a {genre}
FirstResultIntent a {genre}

This shows Alexa how to map the phrase “Alexa ask Movie Genius for a comedy” to the FirstResultIntent and the “comedy” to the “genre” slot. For the built-in intents, you do not need to provide sample utterances.

Asking for an input

SpeechletResponse askResponse(String speechText) {

    // Create the reprompt
    String repromptText = "Can you say that again?";
    Reprompt reprompt = new Reprompt();
    PlainTextOutputSpeech repromptSpeech =
            new PlainTextOutputSpeech();
    repromptSpeech.setText(repromptText);
    reprompt.setOutputSpeech(repromptSpeech);

    // Create the question
    PlainTextOutputSpeech speech =
            new PlainTextOutputSpeech();
    speech.setText(speechText);

    return SpeechletResponse.newAskResponse(
            speech,
            reprompt);
}

// Make Alexa ask a question
askResponse("Hello! What kind of movie do you want?");

The SpeechletResponse object is what you return from the onIntent(..) and what Alexa will transform to speech to communicate with the user. Using the above snippet you can make Alexa ask the user a question to request an input. After Alexa playbacks your question, it will start listening for the user’s input. The reprompt text will be used in case it is not sure about the user’s input and wants the user to say it again. This is how you make a conversational skill.

Responding

SpeechletResponse tellResponse(String speechText) {

    PlainTextOutputSpeech speech = new PlainTextOutputSpeech();
    speech.setText(speechText);

    SpeechletResponse response = 
            SpeechletResponse.newTellResponse(speech);
    return response;
}

This can be used when you want to output your results without expecting the user’s input. You will be finishing a conversation with this response.

Cards in app

SimpleCard card = new SimpleCard();
card.setTitle("Movie Genius");
card.setContent(cardText);
[...]
return SpeechletResponse.newAskResponse(speech, reprompt, card);

Alexa comes with a companion app for iOS and Android that it’s used to set it up. The app can also be used to view Alexa’s activities. Your skill can send to the app useful information that the user might want to see in written form in addition to the speech.

Retaining state

You might want to retain state between responses so you can remember what the user told you in the previous questions. To do this use the Session object that is provided in onIntent(..) and onLaunch(..).

// Retain a movie so you can access it when the user
// asks for more info about it in the next interaction
session.setAttribute("ATTR_MOVIE", theMatrix);

// Retrieve the movie on the next onIntent() call
MovieSet theMatrix = (MovieSet) session.getAttribute("ATTR_MOVIE");

More complicated objects, such as collections, might not be serialized/deserialized correctly when setting/getting them as attributes. In this case, you can serialize then on your own (maybe using Gson to convert them to JSON).

Setup the infrastructure

An Alexa skill can be hosted on your own hosting provider or in AWS Lambda. The latter is the most popular option for hosting Alexa skills since Amazon offers for free the first 1 million requests every month. If you are not familiar with AWS Lambdas, it’s a cloud hosting service for your code that is billed only when it is called and running. That means that you are not charged for all the idle time that your code is waiting to be called. Also, it does not need any server configuration (except for that the amount of RAM needed that will determine how much time your code is allowed to run).

To prepare a Java program for deployment you need to create a JAR file with all the necessary libraries/dependencies included. This is a sample build.gradle file that creates such a JAR (look for the fatJar task).

Then you need to setup the AWS Lambda to serve your Java JAR. To do this, follow the instructions in the README.md of an Amazon’s java sample.(look for the AWS Lambda Setup section).

Finally, you need to setup the Alexa Skill in Amazon Developer Console. Again, follow the instructions in the README.md (look for the Alexa Skill Setup section).

Now, you will be able to test your skill on your actual device, from Amazon Developer Console (look for the Test section) or from the Echo simulator.

Conclusion

I know that this was not a complete tutorial but I hope that I did give you a glimpse/intro on how to make your own skill using Java. The full source code for the skill is on GitHub and live as well if you want to enable it in your Echo. In my opinion, the samples are the easiest way to learn how to do things for your Alexa skill. Do not forget that (if you live in the US or the UK) you can get something for just playing around with your device! Happy coding :)

An adventure with Alexa in Java land. was originally published in Rock and Null on Medium, where people are continuing the conversation by highlighting and responding to this story.