DEV Community: Maria Yudina

A little bit about Lua

Maria Yudina — Sat, 03 Dec 2022 12:37:40 +0000

Introduction

Lua is a lightweight, high-level, multi-paradigm programming language designed primarily for embedded systems and applications. It was first released in 1993 and is used in a wide range of fields, including game development, web development, and scientific computing.

Some of the key features of Lua include:

Small size: Lua has a small footprint, with the entire interpreter fitting in just over 100KB of memory. This makes it well-suited for use in embedded systems and applications with limited resources.
Easy to learn: Lua has a simple and straightforward syntax, making it easy to learn for beginners. It also has a large and active community, with many resources available to help new users get started.
Flexibility: Lua is a multi-paradigm language, meaning it supports different programming styles, such as procedural, object-oriented, and functional. This makes it versatile and allows it to be used in a wide range of applications.
Extensibility: Lua is designed to be easily extended with C libraries, allowing developers to add new functions and features to the language. This makes it a popular choice for game development, where it is often used as a scripting language.

Hello, World!

Here are some basic concepts and syntax to start with the language.

First, Lua is a dynamically-typed language, which means that you don't need to specify the type of a variable when you declare it. Instead, the type of a variable is determined at runtime based on the value it is assigned.

There are eight basic types in Lua: nil, boolean, number, string, function, userdata, thread, and table.

For example, the following code shows how to declare and initialize a variable in Lua:

-- Declare a variable named "x"
x = 10

-- Declare a variable named "name"
name = "John"

In this code, the x variable is assigned the value 10, which is a number, and the name variable is assigned the value "John", which is a string.

Important to mention:

The type number represents both integer numbers and real (floating-point) numbers, using two subtypes: integer and float. Standard Lua uses 64-bit integers and double-precision (64-bit) floats, but you can also compile Lua so that it uses 32-bit integers and/or single-precision (32-bit) floats. The option with 32 bits for both integers and floats is particularly attractive for small machines and embedded systems. (See macro LUA_32BITS in file luaconf.h.) - https://www.lua.org/manual/5.4/manual.html#2

Next, Lua uses indentation to define code blocks, rather than using braces like many other languages. This means that you should indent your code to show which statements are part of a code block, like this:

-- Define a function named "hello"
function hello()
    -- Print a greeting to the console
    print("Hello, world!")
end

The indentation of the print statement indicates that it is part of the hello function.

Basic syntax

In the Lua programming language, there are several reserved words and tokens that have special meaning and cannot be used for other purposes.

Here is a list of some of the reserved words in Lua:

and: Used to perform a logical AND operation.
break: Used to break out of a loop or switch statement.
do: Used to begin a block of code.
else: Used as part of an if statement to specify the code to be executed if the condition is not true.
elseif: Used as part of an if statement to specify additional conditions to be tested.
end: Used to indicate the end of a block of code.
false: Used to represent the Boolean value false.
for: Used to create a loop.
function: Used to define a new function.
goto: Used to jump to the specified label.
if: Used to create a conditional statement.
in: Used as part of a for loop to iterate over the elements of a table or other data structure.
local: Used to declare a local variable.
nil: Used to represent the absence of a value.
not: Used to perform a logical NOT operation.
or: Used to perform a logical OR operation.
repeat: Used to begin a loop that repeats until a specific condition is met.
return: Used to return a value from a function.
then: Used as part of an if statement to indicate the code to be executed if the condition is true.
true: Used to represent the Boolean value true.
until: Used to end a repeat loop and specify the condition that must be met to exit the loop.
while: Used to create a loop that continues as long as a specific condition is true.

In addition to reserved words, there are also several tokens in Lua that have special meaning and cannot be used as identifier names. These include the following:

+: Used to perform addition.
-: Used to perform subtraction.
*: Used to perform multiplication.
/: Used to perform division.
%: Used to perform modulo division.
^: Used to perform exponentiation.
#: Used to get the length of a string or table.
..: Used to concatenate two strings.
<: Used to compare two values to see if the first is less than the second.
<=: Used to compare two values to see if the first is less than or equal to the second.
==: Used to compare two values to see if they are equal.
~=: Used to compare two values to see if they are not equal.
>: Used to compare two values to see if the first is greater than the second.
>=: Used to compare two values to see if the first is greater than or equal to the second.
=: Used to assign the value.
(: Used to begin a block of code or an expression.
): Used to end a block of code or an expression.
{: Used to begin a table constructor.
}: Used to end a table constructor.
[ and ]: Used to index a table.
;: Used to separate statements.
:: Used to separate a method name from its arguments.
,: Used to separate items in a list.
.: Used to access a field of a table or object.
&: Used to perform a bitwise AND.
~: Used to perform a bitwise XOR print(3 ~ 5) or as unary bitwise NOT print(~7).
|: Used to perform a bitwise OR.
<<: Used to perform left shift.
>>: Used to perform right shift.
//: Used to perform the floor division.
::: Used to define labels for blocks of code.
...: Used to represent varargs, which are a variable number of arguments passed to a function.

More information you can find in the official manual.

Variables

In Lua, there are three kinds of variables in Lua: global variables, local variables, and table fields. Variable names must begin with a letter or underscore character, and they can contain letters, numbers, and underscores. They are case-sensitive, so x and X are considered to be different variables.

In the Lua programming language, variables are assumed to be global unless explicitly declared as local. Local variables have lexical scoping, meaning they can be freely accessed by functions defined inside their scope. Before a variable is assigned a value for the first time, its value is nil.

Statements

In the Lua programming language, a statement is a piece of code that performs a specific action or task. There are several different types of statements in Lua, and each has a specific syntax and purpose.

Here are some examples of common statements in Lua:

Assignment statement: Used to assign a value to a variable. For example:

x = 10

Conditional statement: Used to execute a block of code only if a certain condition is met. For example:

if x > 10 then
  print("x is greater than 10")
end

Loop statement: Used to repeatedly execute a block of code. For example:

while x < 20 do
  x = x + 1
  print(x)
end

Function definition statement: Used to define a function. For example:

function add(a, b)
  return a + b
end

Function call statement: Used to call a function. For example:

result = add(10, 20)

These are just a few examples of the types of statements that are available in the Lua programming language.

In Conclusion

The Lua programming language is a powerful and versatile language that is well-suited for a wide range of tasks. It is small, fast, and easy to learn, making it a popular choice for embedded systems and game development.

If you are interested in learning more about the Lua language, there are many resources available to help you get started. Some recommended resources include the official Lua website, which contains documentation and tutorials, and the Lua mailing list, which is a great place to ask questions and get help from the community. There are also many books and online courses available that can help you learn more about the language and its features.

Overall, Lua is a great language to learn and use, and it offers many benefits for developers who want to build efficient and powerful applications.

How to add a condition in SQL with GROUP BY

Maria Yudina — Sat, 03 Dec 2022 11:10:55 +0000

To add a condition to a GROUP BY clause in SQL, you can use the HAVING keyword. The HAVING keyword is used to specify a condition that must be met by the grouped records.

SELECT statements... GROUP BY column_name1[,column_name2,...] [HAVING condition];

For example, the following query uses the HAVING keyword to only include groups that have a count greater than 1:

SELECT column1, COUNT(*)
FROM table
GROUP BY column1
HAVING COUNT(*) > 1;

This query will group the records in the table by the values in column1 and only include groups that have more than one record. The HAVING clause is typically used together with an aggregate function, such as COUNT or SUM, to check for a condition on the values that are being grouped.

It's important to note that the HAVING clause is used after the GROUP BY clause and it operates on the grouped records, whereas the WHERE clause is used before the GROUP BY clause and it operates on the individual records before they are grouped.

Overall, the HAVING keyword is a useful tool for adding conditions to GROUP BY clauses in SQL.

How to Check Directory Size in Ubuntu

Maria Yudina — Sat, 03 Dec 2022 11:05:51 +0000

To check the size of a directory in Ubuntu, you can use the du command. This command stands for "disk usage" and it shows the amount of disk space used by the specified files or directories.

Options:

-h , --human-readable

-s, --summarize

-a, --all

-c, --total

--max-depth

To use the du command, open a terminal window and navigate to the directory whose size you want to check. Then, type du followed by the name of the directory, like this:

du /path/to/directory

This will display the size of the directory in kilobytes. If you want to see the size of all the files and directories inside the specified directory, you can use the -a option like this:

du -a /path/to/directory

This will display the size of each file and directory inside the specified directory, along with the total size at the end.

You can also use the -h option to display the size in a more readable format, such as megabytes or gigabytes, like this:

du -ah /path/to/directory

This will display the size of each file and directory in the specified directory in a human-readable format.

Overall, the du command is a useful tool for checking the size of directories in Ubuntu.

Git errors: cannot checkout branch - error: pathspec 'branch_name' did not match any file(s) known to git

Maria Yudina — Sun, 14 Nov 2021 13:40:58 +0000

Sometimes after repository checkout you can encounter the error trying to switch branches:

git checkout branch_name
error: pathspec 'branch_name' did not match any file(s) known to git

To fix that you can remove remote origin and link it again.
First, check the remote origin:

git remote -v
origin  git@github.com:company/project_name (fetch)
origin  git@github.com:company/project_name (push)

Then remove origin:

git remote remove origin

And add remote origin again with correct path from your repository (copy from GitHub/GitLab/etc.):

git remote add origin git@github.com:company/project_name.git

After that run:

git pull --ff-only

And set upstream to origin branch:

git branch --set-upstream-to=origin/current_branch

After this you should be able to switch between the branches as usual.

This error message indicates that Git was unable to checkout the specified branch because it does not exist. This can happen for a few different reasons, including the following:

The branch name is misspelled or mistyped.
The branch has already been deleted or is no longer available.
The branch exists in a remote repository, but it has not yet been pulled or fetched to the local repository.

To fix this error, you will need to verify that the branch name is correct and that the branch exists in the local repository. If the branch name is correct and the branch still does not exist, you may need to pull or fetch the branch from the remote repository where it exists.

If the branch has already been deleted or is no longer available, you will need to create a new branch with a different name or switch to a different existing branch.

Overall, this error can be resolved by checking the branch name and ensuring that the branch exists in the local repository. If necessary, you can also try pulling or fetching the branch from the remote repository where it exists.

How To Install Go on Ubuntu 20.04

Maria Yudina — Sat, 06 Nov 2021 19:52:36 +0000

Check Ubuntu version

First, run this command to make sure what version of Ubuntu you have:

lsb_release -a

Output example:

No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 20.04.3 LTS
Release:    20.04
Codename:   focal

Install GoLang

Download the latest GoLang archive:

curl -OL https://golang.org/dl/go1.17.3.linux-amd64.tar.gz

Check SHA256 Checksum just in case:

sha256sum go1.17.3.linux-amd64.tar.gz

Extract everything to the usr/local directory:

sudo tar -C /usr/local -xvf go1.17.3.linux-amd64.tar.gz

Update PATH variable in ~/.profile file:

sudo nano ~/.profile

Add new row with export at the end of the ~/.profile file:

export PATH=$PATH:/usr/local/go/bin

Save the changes and exit nano editor. Now we have to refresh your profile. Run this command:

source ~/.profile

Installation and setup is done. Let's check if everything works.

Make sure everything works

We will check Go version and create and run a simple program.

Check the version

Run this command to check Go version:

go version

Output:

go version go1.17.3 linux/amd64

Create and run 'Hello, World!'

Let's create a simple Go program and run it.

Create a directory and switch to it.

mkdir hello_go
cd hello_go

Now we have to create go.mod file with the go mod init command:

go mod init test/hello_go

Create a file where we'll write the program code in Go.

nano hello.go

Copy this example code to the file and save changes.

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Save the changes and exit nano editor.

Run the program:

go run .

Output:

Hello, World!

Done!