Core Math Skills for Data Science: Statistics & Probability

Abhishek Peiris — Fri, 09 May 2025 19:30:30 +0000

Mean, Median, Mode

Term	What It Means	Why We Need It	Real Example	Why Not Another
Mean	Average value	To find the center of data	Average salary in a company	If a few people earn huge salaries (outliers), mean gets unfairly pulled!
Median	Middle value when data is ordered	To find a fair "typical" middle when data has outliers	Median house price in a city	Median is better when data is uneven (e.g., few very expensive houses)
Mode	Most common value	To find the most frequent happening	Most sold shoe size in a store	Mode needed when "most common" is more important than "average"

✅ In short:

Mean = good for normal data.
Median = better when data is skewed (unfair).
Mode = for the most popular thing.

Range, Variance, Standard Deviation

Term	What It Means	Why We Need It	Real Example	Why Not Another
Range	Max - Min value	Quick idea of spread	Highest and lowest test marks in a class	Only shows extremes, not how all values behave
Variance	Average of squared differences from mean	Measure how spread out all data is	Variance of stock prices	Hard to interpret because it's squared units
Standard Deviation	Square root of variance	Easy-to-read spread measure (same unit as data)	How much daily temperatures change from average	Easier to explain to non-math people

✅ In short:

Range is rough and fast.
Variance is deep but harder to read.
Standard Deviation is what we usually tell people.

Correlation and Covariance

Term	What It Means	Why We Need It	Real Example	Why Not Another
Correlation	Strength and direction of relationship between two variables (scale: -1 to 1)	Find if two things move together	Height vs Weight; Study hours vs Exam score	Shows strength and direction both
Covariance	Direction of relationship, but scale is not fixed	Early step before correlation	Stock A and Stock B moving up/down together	Hard to compare across different datasets

✅ In short:

Use Correlation when you want to see if two things are linked.
Covariance is more technical, and only used internally.

Probability

What is Probability?
Probability = chance of something happening.

Example:

Tossing a coin: Chance of Heads = 0.5
Drawing a red card: Chance depends on deck.

Important Probability Concepts

Concept	What It Means	Why We Need It	Real Example	Why Not Another
Independent Events	Events not affecting each other	To model truly random things	Tossing 2 coins separately	Can't assume dependence when there is none
Dependent Events	Events affect each other	To model real-world connections	Drawing 2 cards without replacement	If you assume independence wrongly, you get wrong results
Bayes Theorem	Updating probability when new information arrives	To make smarter decisions after getting new data	Medical test accuracy given patient history	Without Bayes, decision making will be "blind" to new facts

✅ In short:

In real life, events are often dependent → like disease tests, fraud detection.
Bayes theorem makes models smarter when new evidence arrives.

Real-World Data Science Examples

Use Case	Math Concept Used	Why
Predicting customer churn (customer leaving)	Probability + Statistics	Need to model uncertainty
Stock price prediction	Mean, Variance, Standard Deviation	Understand volatility
Health risk prediction (Diabetes, Cancer)	Bayes Theorem + Statistics	Update risk with patient data
Recommendation systems (YouTube, Netflix)	Mode, Correlation	Find popular/common patterns

From Java to Kotlin: A Java Developer's Guide to Kotlin Basics

Abhishek Peiris — Sun, 09 Feb 2025 12:11:23 +0000

Introduction

As a Java Developer, you may have heard of Kotlin, a modern language created by Jet Brains that's gaining popularity for its conciseness and safety. Kotlin is fully interoperable with java, making it easy to adopt without a complete rewrite.

In this guide, we'll cover Kotlin basics, highlighting the key differences and improvements over Java. Whether you're starting a new project or enhancing an existing one, this article will help you quickly get up to speed with Kotlin's syntax, null safety, and powerful features.

Kotlin Syntax Overview:

With an emphasis on minimizing boilerplate code, Kotlin's syntax is intended to be clear and expressive. Many of the principles will seem familiar to Java developers, but Kotlin makes them easier to understand and better.

Variables and Types:

Kotlin uses val for immutable variables and var for mutable ones. Unlike Java, you don’t always need to specify the type because Kotlin can infer it.

val name: String = "Kotlin"   // Immutable
var age: Int = 25             // Mutable

Nullable:

Kotlin also supports nullable types, marked with a ?.

var name: String? = null   // Nullable type

Type Inference:

Kotlin often infers the type of a variable, making the code cleaner and easier to read.

val name = "Kotlin"   // Inferred as String
var age = 25           // Inferred as Int

Null Safety:

Kotlin eliminates the risk of NullPointerException with built-in null safety. You can define nullable types using ?, and safely access them with ?.

val length = name?.length   // Returns null if 'name' is null

The Elvis operator ?: provides a default value when a nullable variable is null.

val length = name?.length ?: 0  // Returns 0 if 'name' is null

Functions:

In Kotlin, functions can be written in a simplified and more flexible way using features like single-expression functions, default parameters, named arguments, higher-order functions, and extension functions. Here's how you can make your functions cleaner and more concise:

Single-Expression Functions:

Instead of using { return ... }, you can use = for simple functions.

// Traditional function
fun square(x: Int): Int {
    return x * x
}

// Simplified version
fun square(x: Int) = x * x

println(square(5)) // Output: 25

Default parameters:

You can provide default values to avoid overloading functions.

fun greet(name: String = "Guest") = "Hello, $name!"

println(greet())       // Output: Hello, Guest!
println(greet("John")) // Output: Hello, John!

Named Arguments (Flexible):

Named arguments allow calling functions in any order.

fun createUser(name: String, age: Int, country: String) = "$name, $age years old from $country."

println(createUser(age = 25, name = "Alice", country = "USA"))
// Output: Alice, 25 years old from USA.

Lambda & Higher-Order Functions:

Kotlin supports passing functions as arguments.

fun operate(x: Int, y: Int, op: (Int, Int) -> Int): Int {
    return op(x, y)
}

// Using lambda functions
println(operate(5, 3) { a, b -> a + b }) // Output: 8
println(operate(5, 3) { a, b -> a * b }) // Output: 15

Extension Functions (Adding Functions to Existing Classes):

You can add functions to existing classes without modifying them.

fun String.firstChar(): Char = this[0]

println("Kotlin".firstChar()) // Output: K

Inline Functions:

In-lining reduces function call overhead.

inline fun repeatMessage(times: Int, action: () -> Unit) {
    for (i in 1..times) action()
}

repeatMessage(3) { println("Hello") }
// Output:
// Hello
// Hello
// Hello

Classes and Inheritance:

In Kotlin, classes are simpler to work with compared to Java. Highlight how classes are declared and the differences with Java’s inheritance model.

Class Definition: Primary constructors are part of the class declaration.
Inheritance: Kotlin classes are final by default. To inherit from a class, use open.

open class Animal(val name: String)

class Dog(name: String) : Animal(name) {
    fun bark() {
        println("Woof!")
    }
}

Data Classes: Automatically Implemented Methods

One of Kotlin's most loved features is the data class, which automatically provides toString(), equals(), and other methods.

data class User(val name: String, val age: Int)

Control Flow: When and If Expressions

Kotlin’s when expression is more powerful than Java’s switch, and if is an expression that can return a value.

If Expression:

val max = if (a > b) a else b

When Expression:

when (x) {
    1 -> println("One")
    2 -> println("Two")
    else -> println("Unknown")
}

Collections: Immutable and Mutable List Operations

Kotlin’s standard library includes powerful features for working with collections.

Immutable Collections: Use listOf().
Mutable Collections: Use mutableListOf() and modify them as needed.

val immutableList = listOf(1, 2, 3)   // Immutable
val mutableList = mutableListOf(1, 2, 3)   // Mutable
mutableList.add(4)

Lambda Expressions: Simplifying Code with Function Literals

Kotlin makes working with functional programming easy with lambda expressions. Java developers will find lambdas in Kotlin very similar to Java 8's lambda expressions.

val add = { x: Int, y: Int -> x + y }
println(add(2, 3))  // Outputs 5

Call to Action

Invite readers to share their experience with Kotlin or ask any questions in the comments. You could also suggest they try out Kotlin in their Java projects or explore resources like the official Kotlin documentation.

DEV Community: Abhishek Peiris

Core Math Skills for Data Science: Statistics & Probability

Mean, Median, Mode

Range, Variance, Standard Deviation

Correlation and Covariance

Probability

Real-World Data Science Examples

From Java to Kotlin: A Java Developer's Guide to Kotlin Basics

Introduction

Kotlin Syntax Overview:

Variables and Types:

Nullable:

Type Inference:

Null Safety:

Functions:

Single-Expression Functions:

Default parameters:

Named Arguments (Flexible):

Lambda & Higher-Order Functions:

Extension Functions (Adding Functions to Existing Classes):

Inline Functions:

Classes and Inheritance:

Data Classes: Automatically Implemented Methods

Control Flow: When and If Expressions

Collections: Immutable and Mutable List Operations

Lambda Expressions: Simplifying Code with Function Literals

Call to Action