In the first episode of this series, I gave you some overview about Solana Project. Now, I will take you on a tour around Solana wallets because it’s the first thing you will interact with on Solana (or any other network). Note that it will be only brief summary (mainly for newcomers) so you have some basic idea what options are there.

SOL Wallets basic categories

• CLI — Solana Tools
• Web -SolFlare, Sollet, MathWallet
• Chrome Extension — Solong
• Mobile — Trust Wallet, Coin87
• HW — Leger S/X
• Desktop/Mobile — Exodus
• …

Wallet list

Solana CLI tools wallet

docs.solana.com/wallet-guide/cli

Core Solana command-line wallet. You interact directly with Solana network without any GUI in between. Most powerful option out there!

Pros: Complete functionality (wallet control, staking, …)

Cons: requires at least basic tech skills, not as user friendly as GUI wallets

Solong

solongwallet.com

Pros: Metamask-like browser extension, decent amount of functions

Cons: Missing some functionality (like no staking features yet)

Sollet

sollet.io

Pros: Open source, good functionality (tokens, …),

Cons: No staking functionality yet, very basic GUI

Solflare

solflare.com

Pros: Nice, feature rich (tokens, staking)

Cons: Not open source yet

Exodus

exodus.com

Pros: Multi-chain, multi-coin, nice UI

Cons: Only send-and-receive SOL, DEX disabled for SOL (temporarily I guess)

Math Wallet

https://mathwallet.org/en-us/

Pros: Multiwallet — multiple networks supported, iOS, Android, Chrome extension, Web wallet

Cons: Basic SOL functions only

Crypto.com

crypto.com/en

Pros: Multi-coin wallet, mobile-only

Cons: Basic SOL functions only, SOL withdrawals not available (last time I checked)

Coin98

coin98.app

Pros: multi-chain wallet

Cons: Basic SOL functions only, mobile-only

Trust Wallet

Pros: multi-chain wallet

Cons: Basic SOL functions only, mobile only

https://trustwallet.com/

Bonfida

https://bonfida.com/wallet

Pros: ERC20 tokens support

Const: not all SOL functions (staking)

Swipe

www.swipe.io

Pros: multi-chain wallet

Cons: Basic SOL functions only, mobile-only

P2P Wallet

p2p-org.github.io/p2p-wallet-web/#/

Pros: good integration with others

Cons: limited-functions for SOL

Leger wallet

www.ledger.com

Pros: hardware+software wallet, HW wallet also supported in multiple other wallets

Conclusion

Well, which one then? It really depends on your needs and preferences. Do you just need to send and receive SOL? Or do you want to stake SOL, or trade tokens on Solana Dexes, Serum, deposit ETC20 tokens, etc? Do you have tech skills?

Can I make any recommendation at all? Yes, I can definitely recommend Ledger Hardware Wallet (not for free, sorry) because it will give you extra layer of security usable in most wallets mentioned and you will use it for your Bitcoins and other crypto as well. There is bad news for Trezor HW wallet users, Solana doesn’t support Trezor yet but I’m pretty sure it will not take a long time and even Trezor will be supported soon.

Otherwise, there are some suggestions based on category you are in. Some wallets are open source, some are not. Also note that several wallets (mostly multi-chain wallets) are centralized and custodial, so you don’t own your crypto but just IOUs (crypto.com, etc).

• Tech skills & security -> CLI wallet
• If you like Metamask -> Solong
• Token maniacs -> Sollet
• Aesthetics, features, staking -> Solflare
• Basic features and multiple coins -> any multi-chain wallet

It’s worth saying that most Solana wallets don’t have the polished quality of Ethereum or BSC wallets yet in general. It’s only showing that we here still quite early, which is good. It doesn’t mean these wallet are unusable, they are pretty decent (some less, others more), they are just not yet perfect.

What do YOU think about Solana wallets? And which one do you prefer and why? Please share you experience with us.

Do you want to support this series with some spare SOL? If so, thank you! 7N7XTh4QmuUm6PhpSApegRKnUAYWk83FLUmzs3ygLzNv

See you next time & blessings!

Welcome! Do you want to learn something about Solana project before summer comes? If so, then you’re on the right place.

Web3 Infrastructure for Everyone

Solana is relatively new scalable hi-performance L1 smart contract block-chain built on very robust, reasonable, sober and rational premise.

Most blockchains are fighting to bring the best solution for the well known trilemma — decentralization, scalability, security. I would say it’s actually quadlemma — decentralization, scalability, security and composability.

Most of the other blockchains do pretty well either one or two areas but rarely any of them can perform well across all these aspects. Solana might be one of those exceptions and probably one of the best candidate to take over or share Ethereum’s crown and I will tell you why.

What is the big deal?

I guess you know Ethereum and you also know why it’s currently pretty expensive to buy few hundreds USD tokens or less on it. Most of us have the same experience. Ethereum is being eaten by its popularity and limited scalability (15TPS) . If you don’t invest $10k or more, it’s basically NO-GO zone. Known issue and not good situation. Even the new fee EIP1559 proposal will not really solve it and Ethereum 2.0 completion is quite far and it will not be easy for developers to implement it right anyway.

One of alternatives, like Binance Smart Chain (BSC) is much better these days but it’s basically ETH PoSA clone doesn’t solve the scalability issue (~50% of its capacity is already eaten) and it’s semi-centralized with only several validators so it’s CeDe solution.

Alternatives

Solana Ecosystem might not yet as great as Ethereum’s or BSC’s but it’s improving fast so it’s the best time to jump onboard, I assume. Cardano or Polkadot, next challengers, are under big hype and although these project are led by great persons and teams, Cardano smart contracts are not yet ready (probably soon) and Polkadot side-chain architecture is not as composable as Solana’s which might be a huge cons. Also Solana has much better entry price that those two which is also important factor.

Even more importantly, there is also no sharding (compared to Ethereum 2.0 for example) or side-chains or sub-networks (as on Polkadot or Avalanche) on Solana and therefore transactions are replicated across all the the nodes and it provides simple reasoning about state of our apps within the network.

Sharding or not

Also because of that, Solana provides the best possible composability as great as Ethereum 1.0 which should be preferred by developers in general as it supports the “Lego effect” without any obstacles. Sharding with good composability is difficult technical problem and as far as I know, only Radix DLT made it right so far.

Even if you have perfect sharding, for many cases it’s just better to know that every node in the network holds complete history. For some applications, sharding can be completely acceptable or even better because it can scale almost limitless, but for some other it might not be the best. In general, more critical application is, less sharding is appreciated. I think both sharded and non-sharded networks will be useful for certain type of applications.

And what is the Solana recipe for success? Technical skills, rational approach, well-thought architecture, strong hardware and optimized software. All this made by pretty qualified team. Now, let’s take a look at Solana basic properties.

Technical specification

• TPS: 50,000 (scales with better hardware and networking up to 700,000 TPS)
• Decentralization: 658 global validators
• Block time: ~400ms
• Average fee per transaction: $0.00001
• Consensus: Proof of History (PoH)
• Block propagation: Turbine protocol
• Transaction forwarding: Gulf Stream protocol
• Parallel smart contract runtime Sealevel
• Validation optimization: Pipelining
• Horizontally-scaled account database Cloudbreak
• Distributed leger store Archivers
• Smart contract: YES (Rust, C, C++ and Solidity layer coming)
• No sharding
• True composability

Solana Token

As any other blockchain network, Solana has its own token called, surprisingly, Solana aka SOL.

• Unit: 1 SOL
• 1 Lamport = 0.000000001 SOL (named after computer scientist Leslie Lamport)
• Total supply: ~ 489 million SOL
• Circulating supply: ~ 264 million SOL
• Current price: $16 (2021–10 -25)
• Market cap: $4B
• Fully Diluted market cap: $8B
• Circulation / Total ratio: ~54%

Where to Buy Solana token? Binance or FTX are probably the best places to buy SOL tokens right now.

Incentives to hold and use SOL

There are plenty incentives why to jump into and hold SOL tokens (no investment advice, though)

• Lots of new projects rising (DeFi and others) are being built on Solana
• Many projects from Ethereum are migrating (or expanding) to Solana
• Great smart contract chain (fast and very low fees aka fragment of USD cent, even way lower than on BSC)
• SOL staking (you can delegate whatever SOL you have to Solana validators) and receive stake reward
• Good entry price so far (compared to ADA, DOT, ETH, …)
• Already some key applications (Serum, etc.)
• Strong team and personalities behind Solana (Anatoy Yakovenko — Solana founder and also Sam Bankman-Fried (SBF)- FTX and Serum founder)
• Future potential in general is pretty huge IMO

KISKIS

How to keep my SOL tokens safe? There are multiple wallets beyond CLI wallet and we will take a look at it in detail in next episodes, for now just see the list below. Note right now only Leger Hardware Wallets (S and X) already support Solana so you can keep your private keys really safe.

SOL Wallets

• CLI — Solana Tools
• Web -SolFlare, Sollet, MathWallet
• Chrome Extension — Solong
• Mobile — Trust Wallet, Coin87
• HW — Leger S/X
• Desktop/Mobile — Exodus

Smart contracts

Smart contract on Solana can be written with robust programming language Rust (and C, C++ and Move) and for easier adoption by the Ethereum smart contract developers, there will be Solidity support very soon (according to some unconfirmed rumors). We will dive into this area in coming episodes.

Conclusion

If you should remember something about Solana, you should remember this:

1. ✅ Solana DOES scale
2. ✅ Solana IS composable
3. ✅ Solana IS decentralized
4. ✅ Robust, secure and fast platform with very low fees
5. ✅ Growing ecosystem getting momentum

In one sentence, Solana is ready for the future! I hope at least I made you more curious about Solana Project and we will definitely dive deeper in next episodes (where we will talk about Solana staking, smart contracts, tools, etc.). For now you can join one of Solana social channels (Telegram, Discord, … see the links below). Or you can try to break Solana :D (https://break.solana.com/)

How about some cons? I already mentioned some and there are few more:

• ecosystem not as mature and polished as on Ethereum or BSC
• no Solidity support yet for easy migration of Ethereum smart contracts
• no Trezor or other HW wallets support (except Ledger)

Disclosure: SOL is part of my crypto portfolio

Ok, that’s all for today and see you next time. Blessings!

Support

In case you want to support this series (and try Solana Network at the same time), feel free to contribute any amount of SOL (yes, even one cent micro-transactions are possible and welcome (+about $0.00001 fee) to the SOL address below.

7N7XTh4QmuUm6PhpSApegRKnUAYWk83FLUmzs3ygLzN

Major Solana Resources

[1] Web site — https://solana.com/

[2] Whitepaper — https://solana.io/solana-whitepaper.pdf

[3] Medium — https://medium.com/solana-labs

[4] Forum - https://forums.solana.com/

[5] Explorer — https://explorer.solana.com/

[6] Beach — https://solanabeach.io/

[7] Reddit — https://reddit.com/r/solana

[8] Telegram — https://t.me/solanaio

[9] Discord — https://discordapp.com/invite/pquxPsq

[10] Docs — https://docs.solana.com/

[11] Github — https://github.com/solana-labs

[12] Congecko — https://www.coingecko.com/en/coins/solana

Why Flutter you may ask? There are many reasons, I advice to search for other articles referring this. But in short, Flutter is modern, popular, widely used framework — “Write once -> have native app everywhere — mobile (Android, iOS), web, desktop (Windows, macOS, Linux)”.

Flutter is made by Google engineers and although Google and some other Alphabet’s companies do some pretty bad stuff these days (censorship, search results manipulation, freedom restrictions, re-captcha, etc.), they still produce and maintain many pretty good policy-agnostic technologies that many developers like and use.

Note that this article works for Ubuntu 20.04 and compatible (and yeah, you will need several gigabytes of free space, at least 10 GB but rather make it 20 GB or more). Official Flutter documentation is good but it will not help you to solve all the troubles on the way you might have on Linux. This article will ease your burden little bit more. Ok, let’s open terminal and start.

STEP 0 — Install OpenJDK 14

You can use Oracle JDK as well and possibly other Java versions but OpenJDK 14 works just fine.

apt install openjdk14-jdk

Check Java version on path

java --version
> openjdk version "14.0.2" 2020-07-14
> OpenJDK Runtime Environment (build 14.0.2+12-Ubuntu-120.04)
> OpenJDK 64-Bit Server VM (build 14.0.2+12-Ubuntu-120.04, mixed mode, sharing)

Now define JAVA_HOME variable in ~/.profile file

export JAVA_HOME=/usr/lib/jvm/java-14-openjdk-amd64/

And execute .profile inside your current shell

source ~/.profile

STEP 1 — Install Flutter

Linux install

At the time of writing this article we have flutter 1.22.4 stable version available. Unpack it into your chosen directory <INSTALL_PATH>

mkdir <INSTALL_PATH>
cd <DOWNLOADS_DIR>
tar xvf flutter_linux_1.22.4-stable.tar.xz -C <INSTALL_PATH>

Add export path to flutter

export PATH="$PATH:<INSTALL_PATH>/flutter/bin"

STEP 2 — Install Android Studio

Download Android Studio (current version 4.1.1)

Download Android Studio & App Tools - Android Developers

tar xvf android-studio-ide-201.6953283-linux.tar.gz -C <INSTALL_PATH>

Now run the Android Studio and install Standard Dependencies as offered.

cd <INSTALL_PATH>/android-studio/bin
./studio.sh

Choose Standard setup and let everything be installed.

STEP 3 — Install Android SDK Command-Line Tools

We need this add “Android SDK Command-line Tools” to run successfully certain commands needed for flutter otherwise you will meet lot of weird errors.

In Android Studio

1. Open Tools > SDK Manager
2. From the left choose, Appearance & Behavior > System Settings > Android SDK
3. Select SDK Tools from the top menu
4. Check Android SDK Command-line tools and click ‘apply’ to install.

STEP 4 — Install Flutter and Dart plugin in Android Studio

If you want to use Android Studio as you Flutter IDE, then it’s good to install Flutter and Dart plugins.

• File -> Settings
• Plugins, type “Flutter” to search the plug-in.
• Click “Install”

Flutter and Dart (you should be asked) plugins will be installed. IDE restart is needed after that.

STEP 5— Accept flutter license

Make Flutter licenses accepted with this command, confirm with ‘y’ whenever asked.

flutter doctor --android-licenses

STEP 6— Set path to Android studio

Now we need to tell Flutter where Android Studio is.

flutter config — android-studio-dir=<INSTALL_PATH>/android-studio

STEP 7—Precache flutter

Populates the Flutter tool’s cache of binary artifacts.

flutter precache --verbose

STEP 8— Enable Flutter web support

To enable web support we need to switch to channel beta as stable channel doesn’t support web development for now.

flutter channel beta

Make sure you’re on the latest build by running upgrade command

flutter upgrade

Now run precache again to populate flutter binary artifacts.

flutter precache

Now it’s time to enable web support

flutter config --enable-web

We should see something like this

Flutter is already up to date on channel beta
Flutter 1.24.0-10.2.pre • channel beta • https://github.com/flutter/flutter.git
Framework • revision 022b333a08 (8 days ago) • 2020-11-18 11:35:09 -0800
Engine • revision 07c1eed46b
Tools • Dart 2.12.0 (build 2.12.0-29.10.beta)

STEP 9— Create and run project

Time to go into your <PROJECT_FOLDER>, folder where your Flutter projects will reside.

cd <PROJECTS_FOLDER>
flutter create flutter_web_app
flutter run -d chrome

Now we should see open browser and Flutter Web Application running in it.

In case you have existing app that doesn’t have web support you will need to run first this command within existing Flutter project.

flutter create .

This will create additional web folder with expected files like index.html, etc. This is not necessary for development but it’s needed for steps like building release web app.

When you are happy with your and and need to generate release build use ‘build web’ command. Your build will be found in build/web folder and can be deployed on various servers.

flutter build web

STEP 10— Check installation

This step is just to see how our Flutter is doing.

flutter doctor

You should see something similar to this except VS Code (for this check you need to install VS Code and Flutter plugin in it). Not necessary if you plan to use Android Studio or other non-vscode editor. But if you want to have all checks green or you want to use vscode , then install vscode flutter plugin in it and run flutter doctor again.

[✓] Flutter (Channel beta, 1.24.0-10.2.pre, on Linux, locale en_US.UTF-8)
[✓] Android toolchain - develop for Android devices (Android SDK version 30.0.2)
[✓] Android Studio
[✓] VS Code (version 1.51.1)
[✓] Connected device (1 available)

That’s all for today. Now you can develop web applications with Flutter with all the comfort Flutter and Android IDE with particular plugins provide. I wish you all your applications run flawlessly and are making this world little bit better and less annoying and troubling place.

1. It’s packed with the Ubuntu 20.04 distribution
2. It’s already well tested and widely used

As we operate on Ubuntu 20.04, let’s log in as root and do the ‘magic’ without unnecessary ‘sudo’ typing.

su - root

STEP#1 — Install PostgreSQL

apt install postgresql postgresql-client

• postgresql — server
• postgresql — client to connect PostgreSQL server

STEP#2 — Check the service

systemctl status postgresql.service

you should see something like this

● postgresql.service - PostgreSQL RDBMS
     Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; vendor preset: enabled)
     Active: active (exited) since Sat 2020-11-21 08:40:52 UTC; 4min 20s ago
    Process: 848 ExecStart=/bin/true (code=exited, status=0/SUCCESS)
   Main PID: 848 (code=exited, status=0/SUCCESS)

Nov 21 08:40:52 vm1 systemd[1]: Starting PostgreSQL RDBMS...
Nov 21 08:40:52 vm1 systemd[1]: Finished PostgreSQL RDBMS.

STEP#3 — Check server can stop and start properly

It’s not necessary step but it would be good to know if service can restart without issues.

# stop the service
systemctl stop postgresql.service
# check it stopped as expected
systemctl status postgresql.service

# start the service
systemctl start postgresql.service# check it started as expected
systemctl status postgresql.service

STEP#4 — Check the executable we can use

Let’s find out what we can use with using apt-file. Let’s install it and create indexes.

apt install apt-file
apt-file update

Now check the files. Note we need to check postgresql-client-12 package because postgresql-client is just a metapackage and will not help here.

apt-file list postgresql-client-12

We should see these utilities

• clusterdb — to recluster tables in PostgreSQL database
• createdb — create new PostgreSQL database
• createuser — define new PostgreSQL user account
• dropdb — remove a PostgreSQL database
• dropuser — remove a PostgreSQL user account
• pg_basebackup — to make a base backup of a PostgreSQL cluster
• pg_config — list exports related to PostgreSQL instance
• pg_dump — extract a PostgreSQL db into a script or archive file
• pg_dumpall — extract a PostgreSQL database cluster into a script file
• pg_isready — check PostgreSQL connection status
• pg_receivewal — stream PostgreSQL log
• pg_recvlogical — control PostgreSQL logical decoding streams
• pg_restore — restore PostgreSQL database from pg_dump archive
• psql — PosgreSQL interactive terminal
• reindexdb — reindex PostgreSQL database
• vacuumdb — garbage collect and analyze PostgreSQL database

We can check the status of PostgreSQL and if it is ready to accept connections.

STEP#5 — Check if postgres user is created

cat /etc/passwd | grep postgres

We should see something like

postgres:x:112:118:PostgreSQL administrator,,,:/var/lib/postgresql:/bin/bash

This means we have postgres user created. Let’s set password for this user

passwd postgres

STEP#6 — Connect to the database

Let’s login as postgres user

su -l postgres

And now connect to PostgreSQL instance and open interactive terminal

psql

STEP#7 —Check the client

Let’s create new database called ‘medium_db’ to see if it is working as expected.

create database medium_db;

Now check if the database exists

\l

We should see something like this

Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges   
-----------+----------+----------+-------------+-------------+-----------------------
 medium_db | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 postgres  | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 template0 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
 template1 | postgres | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/postgres          +
           |          |          |             |             | postgres=CTc/postgres
(4 rows)

All looks good.

STEP#8 — Set postgres DB user password

alter user postgres password 'what_acomplex_password^&*';

This is database user password, don’t confuse with postgres Linux user machine password.

Let’s leave psql now with this command

\q

STEP#9 — Enable remote access

We might need to work with the database remotely.

For that, we need to do some setting changes Let’s edit postgresql.conf accordingly. Switch to root account again and use vim.

vim /etc/postgresql/12/main/postgresql.conf

If you want to allow all IP addresses to remotely access your PostgreSQL instance, you can add this line into connection and authentication section.

listen_addresses = '*'

Also edit /etc/postgresql/12/main/pg_hba.conf which is settings for client authentication control and add line below to the end of the file

host all all 0.0.0.0/0 md5

Be aware this is not good practice as it increase security risk. You should limit remote access as much as possible and rather put list of allowed IP addresses if you need remote access. Also don’t use psql remotely if you don’t have to.

Now restart the server

service postgresql restart

Also make sure your firewall is not blocking default port 5432 or whatever your config states. If your firewall is inactive (which is by default) you are good.

ufw status
# if inactive you should see
Status: inactive

If your ufw (Uncomplicated Firewall) is active and port 5432 is blocked you can simply execute this command under root

ufw allow 5432

STEP#10 —Connect DB from remote machine

Let’s find out DB machine IP address

ip address | grep global

We should see something like

inet [IP]/24 brd [MASK] scope global dynamic enp1s0

On remote machine install just postgresql-client

apt install postgresql-client

Now connect to the remote database

psql -U postgres -p 5432 -h [IP] medium_db

Input ‘ what_acomplex_password^&*’ and you should see

psql (12.5 (Ubuntu 12.5-0ubuntu0.20.04.1))
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, bits: 256, compression: off)
Type "help" for help.

medium_db=#

Now you can use your database remotely and even with remote psql client.

That’s basically is for this tutorial, now you have your database ready to be used. Databases are usually the most critical part of the IT infrastructure. Election results can give you good example how critical database data, settings and security around your database might be. Once your database data is compromised it is very hard to fix it and find out what happened. You might unfortunately not even notice that your data were compromised!

Also be sure that for some use cases, traditional centralized databases are not even the best/right approach. Again, collecting election results or handling financial operations over centralized database is poor approach. For highly critical data, transparent public block-chains or some other similar approaches can give you much more security, transparency and fraud protection.

As developers and other IT guys, we need to have playground to build and play. We need clean playground. We need cheap playground. We need Virtual Machines.

Although I used VirtualBox from Sun, later from Oracle, why not to try KVM. KVM is Kernel Virtual Machine solution, it has friendly license, it’s very flexible and very fast. Cons is, KVM is maybe not as user friendly as VirtualBox but it’s pretty close. Also KVM is not the best for GUI demanding virtualization. But for most kind of servers, it’s great. KVM works the best on Linux, possibly even on Mac and not at all on Windows. Here, I’m using Ubuntu 20.04 based distribution (Desktop for host, Server for VM). Let’s do it in 7 very single steps. Open your console and we can start.

Step 1 — Verify if your processor can make it

egrep -c '(vmx|svm)' /proc/cpuinfo

0 — your CPU cannot make it, other number means hooray!

Step 2 — Verify if your virtualization is enabled in BIOS

Install cpu-checker utility and run kvm-ok to find out.

apt install cpu-checker
kvm-ok

If you see something like this, then you’re good.

INFO: /dev/kvm exists
KVM acceleration can be used

If you are not good, restart computer go in to BIOS and enable VM support (see you motherboard manual for specifics)

Step 3— Install KVM

apt install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils virt-manager

Short information about these packages:

• qemu-kvm — fast processor emulator, compatibility wrapper for kvm
• libvirt-daemon-system — cross-product C virtualization API, libvirt daemon configuration
• libvirt-clients — API and libvirt shell virsh and other client binaries
• bridge-utils — utils for creating Linux Ethernet bridge(s)
• virt-manager — desktop application for managing virtual machines

Step 4— Add current user to libvirt and kvm group

sudo usermod -aG libvirt $LOGNAME
sudo usermod -aG kvm $LOGNAME

Step 5 — Check the installation

virsh -c qemu:///system list

You should see empty list of virtual instances.

Id   Name   State
--------------------

Step 6— Create VM from Ubuntu Server 20.04 ISO

• Download Ubuntu Server ISO https://ubuntu.com/download/server
• Open Virtual Machine Manager
• Click “Create New Virtual Machine”
• Forward
• Choose ISO or CDROM install media: Add path to the downloaded Ubuntu ISO file
• Next and repeat until Ubuntu Virtual Machine Starts
• Install your Virtual Machine whatever way you like and restart it.
• Run virsh the same way you did in previous step and you should see

Id   Name          State
-----------------------------
 1    ubuntu20.04   running

If you see this, then everything works as expected. Congrats! Now you can use Virtual Machine however you want.

Step 7— Adjust VM resources and settings

If you need to boost your VM up or spare some resources, shut down your VM, open Virtual Machine Manager, select your VM with right mouse and click “Open”. Now you should see all the VM settings palette. Here you can change:

• VM name, OS information
• Current and maximum CPU allocation
• Current and maximum Memory allocation
• Boot options
• Network, Display, Sound, USB settings
• Etc.

After the changes and new VM start, your virtual machine will have adjusted resources and device settings. That’s it. Enjoy your VM on KVM.

General

These weeks, anonymous cryptocurrency are driving the crypto markets. Monero is a heavyweight champion here. Let’s take a look if it can beat coming challenger called ShadowCash.

Proof of what

Monero: PoW — CryptoNight (CPU, GPU)
ShadowCash: PoS — PoSv3

Winner: Monero
Detail: Users can benefit from mining which is usually more appreciated than pure PoS coins.

Inflation (annual)

Monero: 19.0388904656 %
ShadowCash: 2%

Winner: ShadowCash
Detail: Lower inflation is considered better. Note: Over years Monero inflation will decrease to almost zero but for now and coming years ShadowCash is having much lower inflation than Monero.

Price / MarketCap

Monero: 12.19$ / 156m $
ShadowCash: 2.12$ / 14m $

Winner: Draw
Detail: ShadowCash is cheaper for new investors but if you already invested in Monero then higher price might not necessarily disadvantage for you.

Codebase

Monero: based on CryptoNote
ShadowCash: based on Bitcoin

Winner: ShadowCash
Detail: Bitcoin codebase is considered better (more secured and proven) than CryptoNote in general.

Community

Monero: large community
ShadowCash: small community

Winner: Monero
Detail: Larger community is definitely big benefit.

Documentation

Monero: average quality
ShadowCash: good quality

Winner: ShadowCash
Detail: Documentation and resource quality is important for new users and developers. Subjectively ShadowCash is one level higher here.

Anonymity features

Stealth addresses, Ring Signatures, Zero Knowledge Proofs, Untraceable, Unlinkable, End to end Anon
Monero: Yes
ShadowCash: Yes

Winner: Draw
Detail: Both projecs are top quality in terms of anonymity features.

Wallet features

GUI Wallet, HTML Interface, Lite Wallet, HD Wallet, Multisignatures

Monero: No
ShadowCash: Yes

Winner: ShadowCash
Details: Monero lacks (for now) GUI wallet and other GUI tools.

Other features

Encrypted chat, marketplace

Monero: No
ShadowCash: Yes

Winner: ShadowCash
Detail: Monero doesn’t provide these additional features (chat, etc.) as part of the project.

Trading

Monero: 7> exchanges
ShadowCash: 3> exchanges

Winner: Monero
Detail: Broader availability and higher liquidity are better. Monero is much better here, there are even many XMR tradeable pairs.

And a winner with is…….

with final score 5 : 7

Congratulations go to ShadowProject Team!

Conclusion

It seems that both projects are great although ShadowCash seems (quite surprisingly) a bit better than Monero and there is also lot of other awesome competitors in the area (Dash, coming ZCash, VCash and others). Of course selected criteria are kind-of subjective (as they can never truly be completely objective) but author’s effort was to give kind of fair comparison to find the best project from these two. If any of these projects wins mainstream adoption it will be great because real war is between anonymous crypto-currencies in general and central banks controlling fiat money.

Disclaimer: This article is not meant to be an investment advice of any kind and so invest carefully based on your own judgement and only with money you can easily lose.

If you’re get used to synchronized way of coding with using threading, etc. and you go into environment like node.js, you’re exposed to an enormous usage of callback practically all the time. By practicing you will be able to read it but in general it’s not very transparent because it’s harder to follow flow and it can lead to “pyramid-code” and “callback hell”.

Fibers are one way how to give your code more synchronized look without changing asynchronous nature.

Callback

Let’s start with a usual callback way. We have code that triggers some long running code (simulated with setTimeout here).

function doSomethingTimeConsuming(description, callback) {
    setTimeout(function() {
        callback && callback(null, 'result for ' + description);
    }, 1000);

}

function doSomething (description) {
    console.log(description + ' initiated');
    doSomethingTimeConsuming(description, function(err, res) {
        console.log(description + ' done with result ' + res);
    });
}


doSomething('first long-time job');
doSomething('second long-time job');
console.log('All commands given');

When we execute it we will get output below.

This is a quite common style and it doesn’t look that bad until we have more complicated code where pyramid scheme occurs. Anyway it would be nice to get rid with all callbacks.

Sync style in async environment

This is something what would be desired:

function doSomethingTimeConsuming(description) {
    setTimeout(function() {
        var result = 'result for ' + description;
        return result;

    }, 1000);

}

function doSomething (description) {
    console.log(description + ' initiated');
    var result = doSomethingTimeConsuming(description);
    console.log(description + ' done with result ' + res);
}

doSomething('first long-time job');
doSomething('second long-time job');
console.log('All commands given');

This obviously will not work as the results are not known when evaluated.

Fibers

Fibers allows us to wrap the code to write it like synchronized block but without blocking others. But it’s not for free (at least in terms of coding). We need to to additional changes.

• require “fibers” library (1)
• create fiber variable in long-running function(2)
• pass result to fiber (3)
• fiber must yield until result is given not to block others (4)
• wrap and run request into Fiber (5)

var Fiber = require('fibers'); // (1)

function doSomethingTimeConsuming(description) {
    var fiber = Fiber.current; // (2)
    setTimeout(function() {
        fiber.run('result for ' + description); //(3)
    }, 1000);
    var results = Fiber.yield(); //(4)
    return results;
}

function doSomething (description) {
    Fiber(function() { // (5)
        console.log(description + ' initiated');
        var result = doSomethingTimeConsuming(description);
        console.log(description + ' done with result ' + result);
    }).run();
}

doSomething('first long-time job');
doSomething('second long-time job');
console.log('All commands given');

Now the code works as expected with eliminating all callbacks.

Fibers are possible way but every one must decide when it’s worth to use it or to use callback or another library like Async, Step, Syncify or wait to async in ES7.

For the LORD has called you back from your grief — as though you were a young wife abandoned by her husband,” says your God. (Isaiah 54:6)

Recently I needed to create custom server service on Debian Jessie (wich is version 8) and there is systemd used as a service system. Systemd is very complex but if you are not an expert, this brief article will show you simple way for creating general server service.

Topic: Create own systemd service
OS: Debian 8 (Jessie)
Tool: systemctl, service, vim

List services

“systemctl” is basic command to work with systemd service. When executes, it lists all services. Just type:

systemctl

Create service

Service definition files (on Debian 8) are located under /lib/systemd/system/. We just need to create a new one. Our newly created file will be /lib/systemd/system/myservice.service

[Unit]
Description=My custom service
After=network.target

[Service]
Type=forking
PIDFile=/run/myservice.pid
ExecStart=/root/bin/myServiceStart.sh
ExecStop=/root/bin/myServiceStop.sh
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=myservice

[Install]
WantedBy=multi-user.target

Referenced sh scripts contain server execution instructions, “Type forking” provides daemon like process execution usually used with optional PIDFile. Here we need network service as a prerequisite and we expect scripts output available in syslog. This definition should work well for some terminal server service executed from script files. If you have another type of service, you’ll have to modify it according to your specific needs.

Enable service

Here we are using “systemctl” but we can also use “service” command for hese obvious operations.

systemctl enable myservice

Disable service

systemctl disable myservice

Stop service

systemctl stop myservice
# or
service myservice stop 

Start service

systemctl start myservice
# or
service myservice start

Service logging and status

To see log messages you can just read syslog content:

cat /var/log/syslog

We can also check service status like this:

systemctl status myservice

That’s all, everything should work now. For more about systemd, check man pages.

Slaves, obey your earthly masters with fear and trembling, with a sincere heart, as you would Christ, not by the way of eye-service, as people-pleasers, but as servants of Christ, doing the will of God from the heart, rendering service with a good will as to the Lord and not to man, knowing that whatever good anyone does, this he will receive back from the Lord, whether he is a slave or free. (Ephesians 6:5)

When I started with JS, I really had poor understanding of things behind objects. Still far from being an expert in the area, some fog has disappeared. In strong OOP languages, we usually compose classes or use inheritance. in JS, especially before ES6, we have just objects which we can extend via mixins. Here JS can be quite confusing for traditional OOP developers. To understand JavaScript mixins, it is needed to understand objects and their prototypes.

Objects

An object in JS is some composite for a bunch of key-value pairs sometimes called properties including reference into “upper” objects called prototypes. We can imagine this like some bunch of added behavior and properties accessible. From OOP perspective, it is like super-class.

To create a new object with an undefined prototype we use Object.create function.

var objectWithUndefinedPrototype = Object.create(null);

To add new property name and value to this object we have multiple ways how-to do it, most simple is “dot” notion:

objectWithNotDefinedPrototype.name = 'John';

Often we create objects with basic “Object” prototype. For this we can use simplified construction:

var objectWithObjectPrototype = {};
// which is a syntax suggar for
var objectWithObjectPrototype = Object.create(Object);

More about prototypes

Prototype can be understood also as a pointer to another object. It allows property chain lookup. So we can utilize content defined in object prototype. Property lookup goes from used object up to top prototype until it’s found if there is any in the chain. The lookup is stopped when a property is found or there is no upper prototype (ie. it’s null) and then an undefined value is returned.

More about properties

As we can simply create property just by simple notion <object>.<property_name> = <property_value>. There is more detailed way by using Object.defineProperty function.

var dog = Object.create(null);
Object.defineProperty(dog, 'name', {
  value: "Woofy",
  writable: true,
  enumerable: true,
  configurable: true
});

Define properties with common defaults

We can create a function to simplify property definition.

var config = { 
  writable: true, 
  enumerable: true, 
  configurable: true 
};

var defineProperty = function(obj, name, value) {
  config.value = value;
  Object.defineProperty(obj, name, config);
}

var person = Object.create(null);
defineProperty(dog, 'name', 'Woolfy');
defineProperty(dog, 'age', 7);

Create object hierarchy

Prototypes are basic stones for creating object hierarchies similar to inheritance in OOP languages. Like this, we can create object “circle” which can utilize properties from object “shape”. If we pass “shape” as parameter to Object.create parameter, circle will have shape as its prototype.

var shape = Object.create(null);
defineProperty(shape, ‘color’, ‘black’);

var circle = Object.create(shape);
defineProperty(circle, 'radius', 1);

// now we can check
console.log(circle.color); // black
console.log(circle.radius); // 1

Prototypes with __proto__

There is a special properties called __proto__. We can create the same with this property

var shape = {};
shape.__proto__ = null;
shape.color = 'black';

var circle = {};
circle.radius = 1;
circle.__proto__ = shape;

// now we can check
console.log(circle.color); // black
console.log(circle.radius) // 1

Note that shape is not the same as shape from the previous example as its prototype is “Object” here.

Construction below is the same and so {} is a syntax suggar for creating objects with Object prototype.

var myObj = {};
var myObj = Object.create(Object);

Getting prototype

By using Object.getPrototypeOf we can get prototype of the object.

var myObj = {};
Object.getPrototypeOf(myObj); // => Object
// or
myObj.__proto__; // Object

Constructor functions and “new” keyword

Keyword “new” creates new object so-called “instance of the function”. We can use “instanceof” keyword to check instance type.

function Dog() {};
var dog = new Dog();

console.log(dog instanceof Dog); // ==> true

‘this’ reference keyword

Using “new” injects “this” reference to the new object that is being created and can be used in this constructor function. Note: Be careful when calling such a function (instead of using “new” keyword). In such a call “this” would refer to global scope instead of function scope.

function Dog() {
  this.name = 'Woolfy';
}

var woolfy = new Dog('Woolfy');
foo.name; // ==> 'woolfy';

Function prototype

Note that “prototype” is not necessarily equal to “__proto__”. There is a relation, though. When new object is created, __proto__ of the new object is the same as “prototype” property of function which created the object. There is simple example

function Dog(name) {
  this.name = name;
}

var woolfy= new Dog('Woolfy');
woolfy.__proto__ == Dog.prototype; // => true

Classes

Until ES6, we have several approaches for creating structures similar to class. Let’s start with “anti-pattern” approach where we refer to outer function.

function Dog(name) {
  this.name = name;
  this.getName = getDogName;
}
function getDogName() {
  return this.name
}

var dog = new Dog('goofy');
console.log(dog.getName());

Let’s do it better without exposing outer function

function Dog(name) {
  this.name = name;
  this.getName = function() {
    return this.name;
  }
}

var dog = new Dog('goofy');
console.log(dog.getName());

Another approach by using prototype

function Dog(name) {
  this.name = name;
}
Dog.prototype.getName = function() {
  return this.name;
}

var dog = new Dog('goofy');
console.log(dog.getName());

There are other ways how to achieve the same, for example by using object literals. Anyway, ES6 ha brought “class” keyword so we can define prototypes of objects in cleaner OOP fashion.

class Dog {
  constructor (name) {
    this.name = name;
  }
  getName() {    
    return this.name;
  }
}

var d = new Dog('woofy');
console.log(d.getName());

Mixins

Mixins allow us to compose/expand multiple objects. Mixin is done by Object.assign function. A first parameter is an object prototype that is going to be expanded and a second parameter is an object that should be added.

function Dog(name) {
  this.name = name;
  this.getName = function() {
    return this.name;
  }
}

const Colored = {
  color: 'red',
  getColor: function() {
    return this.color;
  }
};

Object.assign(Dog.prototype, Colored);
var d = new Dog('woory');
console.log(d.getColor());

Functional mixins

We can rewrite this into a functional form.

function Dog(name) {
 this.name = name;
 this.getName = function() {
   return this.name;
 }
}

const Colored = (target) => 
  Object.assign(target, {
  color: ‘blue’,
  getColor() {
    return this.color;
  }
});

Colored(Dog.prototype);
var d = new Dog(‘woory’);
console.log(d.getColor());

There are some more constructions possible as JS is very flexible but for basic understanding this should be enough. When compared with some traditional OOP languages, JS is more powerful allowing more advanced constructions and also requires a slight mental shift. On the other hand, syntax tends to be more error-prone. Although ES6 brings more transparent constructions, historical burden stays.

In times when JavaScript was much slower and more terrible than it’s now, I’ve used Dart for a web/canvas app and found it very nice. Dart Editor based on Eclipse RCP worked (surprisingly) well and Dart language provided all language features I expected that time.

Today, in time of ES6, when JS and node.js is quite a synonym for a web development, one might ask: Is there still a place for Google Dart?

I’ve read many articles about this (mainly written in 2015) and it seems that opinions were mostly against Dart. As many developers tend to follow mainstream technologies, challenger must always bring something special.

We have March 2016 now and JavaScript is constantly evolving but still it’s bearing many unfortunate decisions from the past as a historical burden. As ES6 doesn’t look bad, overall language impression is still behind enterprise expectations. JavaScript was, is and probably always will be “the ugly” language. People might get use to it, but the existence of all these CaffeScrpts, TypeScripts and also Dart is the best proof that JavaScript is just a necessary evil.

On the other hand, Dart was nicely designed language since the beginning. So why there is such a low adoption. Let’s try to summarize current state of main advantages JS vs Dart:

JavaScript pros:

1. Native support in browsers
2. Native support in browsers
3. Native support in browsers

Dart pros:

1. Well-designed language
2. Performance
3. API

When I was using Dart, there was a still a living plan and hope to have native language support in major browsers. As my app was subjectively maybe ten times faster in Dartium I was thinking that I’m ready for the future. That’s why I was very surprised that Google decided to leave native support and focus on dart2js.

I always understood that there is a good chance that MS and Mozilla will never implement Dart VM in their browsers but that never bothered me much. If there is just Google supported browser with native Dart, it would be good enough I said to myself. What a surprise they decided to leave it behind. Many Dart users felt betrayed. Here I must join the crowd — that decision was the worst decision that Dart team ever did!

Anyway, people do mistakes and people can still re-consider and fix some of them. These can be fixed. I’m not saying I will not use Dart anymore but now I would need to have extremely strong reason for using it now.

Google doesn’t have the best reputation in terms of maintaining technologies long-term, still Dart can be widely adopted if these two conditions are fulfilled:

1. Strong promise that there WILL BE a supported Google browser with native Dart after all
2. A promise that Dart platform will be supported by Google at least next 10 years

These two promises would bring Dart back into the prime league.

I believe Google invested and is still investing a lot to develop and promote Dart and to keep it evolving and so I believe (2) is already true and although it would be nice to hear it officially. But still (1) is a MUST!

To finish this with a positive note, language popularity seems to be slowly increasing, language is nicely evolving and IDE based on Webstorm/Idea also looks very nice.