Sheerpower Logo

Variables, Data Types, Declaring Variables, Comments, and Database Access

The Fundamentals of Sheerpower Programming

Welcome to the fundamentals of Sheerpower! In this tutorial, you'll learn how to store information in variables, understand the different types of data you can use, and how to document your code with comments. Along the way, you'll also see how Sheerpower's naming conventions and type system keep programs clear and easy to read.

1. Understanding Variables

Variables are containers for storing data. In Sheerpower, a variable name must begin with a letter and can contain letters, numbers, and underscores. Variable names are case-insensitive and typically use underscores to improve readability, like tax_rate or full_name$.

Sheerpower also reserves two special throw-away identifiers: _ for numbers and _$ for strings. They are write-only targets—assign to them when you want an expression to run but intentionally ignore its return value. This makes your intent clear at a glance.

For example, the join() function quickly joins strings together and returns the final length. If we don't need the length, we can do this:

a$ = '' _ = join(a$, 'Admin: ', name$) // string build, no need to keep the returned length

2. Sheerpower's Core Data Types

Every variable holds a specific type of data. Sheerpower's core data types are:

STRING

For text.

"Hello!"

REAL

For numbers.

123.45

BOOLEAN

For true/false.

true

INTEGER

Rarely used. Use REAL instead. Sheerpower's REAL type handles whole numbers perfectly, making a separate INTEGER type unnecessary for most arithmetic.

42

DYNAMIC

Inherits the data type of the last value assigned.

Design Rationale: Why use dynamic data types?
  • Adapts to mixed data: Perfect for code that handles user input, file data, or API responses that might change type from one call to the next.
  • Type stability after assignment: Once a value is assigned, the variable behaves as that type until it is assigned something else.
declare dynamic x x = "hello" // now x is a STRING x = 3.14159 // now x is a REAL x = 42% // now x is an INTEGER

3. Two Ways to Create Variables

Variables can be created either implicitly (by using type suffixes) or explicitly (with the declare statement). Sheerpower supports both styles, so you can choose the one that fits your code and team conventions.

  • Implicitly (with suffixes): Concise and expressive. A suffix indicates the variable's type and often improves readability:
    • $ for a STRING (e.g., name$)
    • ? for a BOOLEAN (e.g., found?) — read it as a question
    • % for an INTEGER (e.g., count%)
    • No suffix for a REAL (the default for numeric values)
    Many developers prefer suffixes because they make the type and purpose of a variable obvious at a glance, especially for booleans and strings.
  • Explicitly (with declare): Can improve clarity, organizes declarations, and reduces errors. This is especially helpful in larger programs or shared codebases.
Strict Mode Option:
Add OPTION REQUIRE DECLARE to enforce explicit declarations. The compiler will raise an error if a variable is used without being declared first.

This ensures tighter control and catches typos or undeclared variables early. You can still use suffixes with declare if you like the clarity they provide (for example, declare boolean found?).
// Implicitly created variables full_name$ = "Sally Sue" is_active? = true total_cost = 19.95 // Explicitly declared variables declare string shipping_address declare real weight declare boolean item_available shipping_address = "123 Main St" weight = 2.5 item_available = true

4. A Special Note on REAL and High-Precision

Sheerpower’s REAL type is designed for exact decimal arithmetic. Unlike IEEE floating-point types used in most languages, REAL values deliver 16 digits of true decimal precision, avoiding the rounding errors that plague floating-point math. This makes REAL ideal for financial, accounting, and other applications where accuracy is critical.

Each REAL is stored as two 64-bit integers: one for the integer part (IP) and one for the fractional part (FP), scaled by 1016. For example, 13.599 is internally represented as:
IP = 13
FP = 5990000000000000

This design eliminates floating-point approximation and enables efficient comparisons and arithmetic. Expressions like (0.1 + 0.2) - 0.3 evaluate to 0 in Sheerpower.

By contrast, the same expression in IEEE math yields:
0.00000000000000005551115123125783

(0.1 + 0.2) - 0.3
⇓
Sheerpower: 0
Other Languages: 0.00000000...555

Sheerpower is strongly typed. A STRING value—even one like "123.45"—cannot be assigned directly to a REAL variable. This results in a compile-time error unless you explicitly convert it.

5. Custom Data Types

Sheerpower lets you define your own constants and custom data types. These features make code more readable, expressive, and secure.

Constants

// A constant’s value cannot be changed after definition. const everything = 42

Custom Data Types

// Define a new type named 'money' based on REAL type real money // Declare a variable using the new type declare money monthly_salary monthly_salary = 5000.00

This makes code more self-explanatory—using money signals financial data, not just a number.

Secure Custom Types

// Create a secure string type for sensitive data type nodump string secret // Declare a variable using the secure type declare secret password password = "xxyyy"

If the program crashes, password appears as <nodump> in debug output—protecting secrets from accidental exposure.

Why It Matters:
Problem: Debug output and crash logs can accidentally expose sensitive data like passwords or tokens.

Solution: The nodump modifier ensures those values are hidden, showing <nodump> instead of the actual contents.

Efficiency: This adds no runtime overhead—security is enforced automatically by the runtime.

Takeaway: Use nodump for secrets or private data to keep applications safe without extra coding effort.

6. Formatting Your Output

// This variable prints with a $, comma, and 2 decimal places. declare format "$%.2m" price price = 12300.456 print "Total price: "; price // Output: Total price: $12,300.46

Format Syntax

  • $ – Literal dollar sign
  • %.2m – Two decimal places in monetary format
declare format "%.1f%%" success_rate success_rate = 98.73 print "Success: "; success_rate // Output: Success: 98.7%

7. A Quick Look at Database Variables

Sheerpower provides a secure way to access table fields using table_name(field_name). This separates code from data and protects against SQL injection.

Payroll Table
id name salary
⇓
payroll(salary) = 55000.00

Database access is an advanced feature. To learn more, see the Integrated Database Access tutorial.


8. Documenting Your Code with Comments

Comments are ignored by the compiler and help others understand your code. Use // (preferred) or ! to begin a comment.

// This is a comment. It explains the next line. const tax_rate = 0.08 // 8% sales tax // Good comments explain the "why," not just the "what." // Calculate the final price including tax. final_price = subtotal * (1 + tax_rate)

9. Converting Between Strings and Numbers

Sheerpower enforces variable types. You cannot assign a STRING directly to a REAL or vice versa — use conversion functions.

Converting a String to a Number

declare real price declare string input$ input$ = "12.95" price = val(input$)

For a complete walkthrough, see the val() function tutorial .

Converting a Number to a String

declare string output$ declare real tax = 0.075 output$ = str$(tax)

Conversions like val() and str$() are commonly used when reading user input, importing raw data, or constructing strings for display.

10. Putting It All Together

const sales_tax_rate = 0.08 declare string item_name$ declare real item_price, quantity item_name$ = "Super Gadget" item_price = 29.95 quantity = 2 subtotal = item_price * quantity final_total = subtotal * (1 + sales_tax_rate) print sprintf("Item: %, Qty: %, Total: $%.2m", & item_name$, quantity, final_total) a$ = '' _ = join(a$, 'Admin: ', name$) // string build, no need to keep the returned length

What You've Learned

  • Variable naming rules and optional type suffixes
  • Core types: STRING, REAL, BOOLEAN, with optional INTEGER
  • Dynamic variables that adapt type from assigned values
  • REAL type with exact 16-digit decimal precision
  • Implicit vs. explicit declarations
  • Strict mode with OPTION REQUIRE DECLARE
  • Constants and custom types (including nodump)
  • Formatting with declare format
  • Intro to database variables
  • Comments (! and //)
  • Conversions with val() and str$()
(Show/Hide Variable & Data Type Takeaways)

Hide Description

    

        


      

      
Enter or modify the code below, and then click on RUN

     

    		

  

  
  

    
    

    
  
  

  
  

  
 

  



    

    Looking for the full power of Sheerpower? 
    

    Check out the 
   
   Sheerpower website.
   
   Free to download.  Free to use.