---
title: 'Why Test-Driven Development is important for writing secure smart contracts'
date: '2023-03-02'
featured: '/images/coin-lock.png'
description: 'Should you be writing tests first then code? Yes'
---

## Why you should be writing tests first
Smart contracts are self-executing computer programs that are stored on a blockchain. They are designed to execute automatically when certain conditions are met, and they have the potential to revolutionize industries such as finance, real estate, and supply chain management. However, smart contracts can also be vulnerable to attacks, and if they are not properly secured, they can result in significant financial losses.

One way to ensure that smart contracts are secure is to use test-driven development (TDD). TDD is a development process that involves writing tests before writing the code. The idea behind TDD is that if you write the tests first, you can ensure that the code you write will pass those tests, which means that the code will be correct and functional.

Here are some reasons why TDD is important for writing secure smart contracts:

### TDD helps to catch bugs early
* One of the biggest benefits of TDD is that it helps to catch bugs early in the development process. By writing tests first, you can identify potential issues before they become more significant problems. This is especially important when it comes to smart contracts, where bugs can result in significant financial losses.

### TDD ensures that the code is correct and functional
* Another benefit of TDD is that it ensures that the code is correct and functional. By writing tests first, you can ensure that the code does what it is supposed to do. This is important when it comes to smart contracts, where even small errors can have significant consequences.

### TDD helps to ensure that the code is maintainable
* TDD also helps to ensure that the code is maintainable. By writing tests first, you can ensure that the code is modular and easy to update. This is important when it comes to smart contracts, where updates may be necessary to address security vulnerabilities or to add new functionality.

### TDD helps to ensure that the code is secure
* Finally, TDD helps to ensure that the code is secure. By writing tests that simulate attacks and other security threats, you can identify potential vulnerabilities before they can be exploited by attackers. This is critical when it comes to smart contracts, where security is paramount.

In conclusion, test-driven development is a critical process for writing secure smart contracts. By writing tests first, you can catch bugs early, ensure that the code is correct and functional, make the code maintainable, and ensure that the code is secure. If you are developing smart contracts, be sure to incorporate TDD into your development process to ensure that your smart contracts are as secure as possible.


Should you be writing tests first then code? Yes

Why Test-Driven Development is important for writing secure smart contracts

---
title: 'New features added to chatgpt-vim'
date: '2023-03-01'
featured: '/images/gpf-gpr-demo.gif'
description: 'chatgpt-vim just got 2 new features!'
---

## Introduction
Vim is a highly customizable text editor that offers a wide range of features for developers and text enthusiasts. One of the most popular features of Vim is its plugin system, which allows users to extend its functionality in various ways. [chatgpt-vim](https://github.com/0xStabby/chatgpt-vim) is a Vim plugin that integrates with the OpenAI API to generate text based on user inputs. We'll cover the new functions that were added in the latest release - GPTFile and GPTRun.

## The Plugin Code
The plugin code defines three functions - GPT, GPTRun, and GPTFile - that communicate with the OpenAI API to generate text based on user inputs. These functions are then bound to commands that can be executed within Vim, and three key mappings are created for convenience - gpt, gpr, and gpf. Let's take a closer look at each of these functions.

### GPT
* The GPT function prompts the user to enter a chatgpt prompt and sends it to the OpenAI API using the openai complete command. If the OPENAI_API_TOKEN environment variable is set, the API token is used for authentication. Otherwise, the token is read from the ~/.config/openai.token file. The generated text is then displayed in the Vim command line, and the user is prompted to insert the output at the current cursor position.

### GPTRun (new)
* The GPTRun function prompts the user to confirm whether to run the current file using a specified command and sends the file contents along with a message to the OpenAI API. The generated text is displayed in the Vim command line, and the user is prompted to insert the output at the current cursor position.

### GPTFile (new)
* The GPTFile function prompts the user to confirm whether to send the contents of the current file along with a message to the OpenAI API. The generated text is displayed in the Vim command line, and the user is prompted to insert the output at the current cursor position.

## Conclusion
The Vim plugin we discussed in this blog post provides an easy way to generate text based on user inputs and can be used for a variety of tasks, such as generating code suggestions, answering questions, or generating text summaries. The new functions added in the latest release - GPTFile and GPTRun - provide additional functionality and make the plugin even more versatile. If you're a Vim user and you haven't tried the [chatgpt-vim plugin](https://github.com/0xStabby/chatgpt-vim) yet, give it a shot and let us know what you think!

### More Info
For more info you can checkout this [blog post](/blog/yes-chatgpt-helped-me-make-a-chatgpt-vim-plugin) or the [chatgpt-vim github](https://github.com/0xStabby/chatgpt-vim)


New features added to chatgpt-vim

---
title: 'Writing secure smart contract code with solidity'
date: '2023-02-28'
description: 'How to write secure solidity contracts, tips and tricks'
---

## How to write secure solidity contracts, tips and tricks

Smart contracts are self-executing contracts with the terms of the agreement between buyer and seller being directly written into lines of code. As such, it is essential that smart contracts are secure and error-free to prevent malicious attacks and ensure the smooth functioning of the blockchain network.

Solidity is the most commonly used programming language for writing smart contracts on the Ethereum blockchain. In this blog post, we will outline some best practices for writing secure Solidity smart contract code.

### Keep it Simple
* The first and most important rule of writing secure Solidity smart contracts is to keep it simple. This means writing code that is easy to read and understand. Complex code can lead to bugs and make it difficult to spot vulnerabilities.

### Follow the Principle of Least Privilege
* The Principle of Least Privilege (PoLP) is a security concept that states that users should be given the minimum amount of access they need to perform their tasks. In Solidity smart contracts, this means restricting access to certain functions and variables. By limiting access, you reduce the potential for malicious actors to exploit vulnerabilities in your code.

### Use SafeMath Library
* One of the most common vulnerabilities in Solidity smart contracts is integer overflow and underflow. The SafeMath library is a tool that helps prevent these vulnerabilities by providing a safe way to perform arithmetic operations on unsigned integers. Always use the SafeMath library when working with integers in your smart contract.

### Beware of Re-Entrancy Attacks
* A re-entrancy attack is a type of vulnerability that allows an attacker to repeatedly execute a function before the previous execution has completed. This can result in unintended consequences such as theft of funds. To prevent re-entrancy attacks, always use the modifier "nonReentrant" to ensure that a function cannot be called again until the previous execution has completed.

### Use Time-Stamp for Security Checks
* When writing Solidity smart contracts, you may need to implement time-based security checks such as limiting the frequency of certain functions. To do this, use the "block.timestamp" function to get the current timestamp of the blockchain. Be aware that this function can be manipulated by miners, so use it judiciously.

### Test Your Code Thoroughly
* Thoroughly testing your Solidity smart contract code is crucial to ensure its security and reliability. Use tools such as Truffle and Ganache to simulate the blockchain environment and test your code under different conditions. Make sure to test for edge cases and ensure that your code works as intended.

In conclusion, writing secure Solidity smart contract code requires following best practices and being diligent in your testing. By keeping your code simple, following the Principle of Least Privilege, using the SafeMath library, preventing re-entrancy attacks, using time-stamp for security checks, and testing your code thoroughly, you can minimize vulnerabilities and ensure the smooth functioning of your smart contract.


How to write secure solidity contracts, tips and tricks

Writing secure smart contract code with solidity

---
title: 'ChatGPT helped me make a ChatGPT Vim plugin.'
date: '2023-01-06'
featured: '/images/chatgpt-vim.gif'
description: 'ChatGPT helped me make a ChatGPT Vim plugin.'
---

_[chatgpt-vim](https://github.com/0xStabby/chatgpt-vim) used to generate a working todo app out of html/js_

## ChatGPT helped me make a ChatGPT Vim plugin

Have you ever wished you could use GPT-3's language generation capabilities
directly from your favorite text editor? Well, now you can! I'm excited to
announce the release of the [chatgpt-vim plugin](https://github.com/0xStabby.com/chatgpt-vim).

This plugin allows you to access the [ChatGPT](https://chat.openai.com/chat) API (a variant of GPT-3) directly
from Vim, allowing you to generate text snippets, complete code blocks, and
more. It's a great tool for writers, developers, and anyone looking to save time
and increase productivity.

But the story of how this plugin came to be is just as interesting as the plugin
itself. You see, I used ChatGPT to help me write the documentation and code for
the plugin itself. That's right – ChatGPT helped me build a ChatGPT Vim plugin.

I started by asking ChatGPT to write the basic structure and documentation for
the plugin. From there, I was able to use its suggestions and output to guide
the development process. Along with some trial and error. 
It was a powerful way to use the tool, and it allowed me to move much 
more quickly than I would have been able to on my own.

Overall, the ChatGPT Vim plugin is a great example of the potential for
AI-powered tools to augment and enhance our work. I hope you find it as useful
as I do!


### Installation

To install the ChatGPT Vim plugin, follow these steps:

 1. Download the plugin files from the [chatgpt-vim](https://github.com/0xStabby/chatgpt-vim).
 2. Copy the files to your ~/.vim directory.
 3. Add the following line to your ~/.vimrc file: source ~/.vim/chatgpt.vim
 4. Restart Vim and you're ready to go!


### Usage

To use the [chatgpt-vim](https://github.com/0xStabby/chatgpt-vim) plugin, simply type `gpt` in normal mode followed by your prompt. 
For example, to generate a code block, you might type:

`gpt` > `Generate a Python function to reverse a string`

The plugin will:
1. Send your prompt to the ChatGPT API
2. Display the result to you
3. Ask if it should insert the generated text into your document at the current cursor.

I hope you enjoy using the [chatgpt-vim plugin](https://github.com/0xStabby.com/chatgpt-vim)! Let me know if you have any feedback or questions.


ChatGPT helped me make a ChatGPT Vim plugin.

---
title: 'Using Blender, on Linux, through an IPad'
date: '2023-01-03'
featured: '/images/TabletTools-with-Blender.jpeg'
description: 'How to use Blender on Linux through an IPad'
---

## How to use Blender on Linux through an IPad.

![Using Tablet Tools with Blender](/images/TabletTools-with-Blender_Quality.gif)

## My current setup for getting this to work nicely

Prerequisites:

* [Weylus](https://github.com/H-M-H/Weylus) (to connect ipad to linux)
* [TabletTools](https://github.com/0xStabby/TabletTools) (for hotkeys to make this more useable)


Firstly, before connecting through weylus we will need a screen to share.
Through Weylus you are able to share, either:

* Full Desktop
Doesn't really work if you have a large or multimonitor setup,

* Full Monitor
Works but would be nice to have a virtual monitor over duplicating a monitor,

* Single Application
Works, but unable unable to use a second application for hotkeys

So with all our options, for me the best one was Full Monitor, but with a virtual monitor as to use the Ipad as another screen, and not just a duplicate.

To do this we will use xrandr to create and add a new mode and output to our new virtual monitor:

Decide a resolution, may be some guessing here, but can find resolutions for ipads on the internet to start from. I use an Ipad Pro so the resolution I ended with after some tweaks is 1368x1000, this accounts for the space lost to the status bar at the top of the Ipad OS.

To create a new mode for xrandr we will use cvt to create a new mode line for our specifications.
The last number being the refresh rate.
```sh
cvt 1368 1000 60

```
This will give you a result like:
```sh
# 1368x1000 59.95 Hz (CVT) hsync: 62.22 kHz; pclk: 113.00 MHz
Modeline "1368x1000_60.00"  113.00  1368 1448 1592 1816  1000 1003 1013 1038 -hsync +vsync

```

Use the Modeline to create a new xrandr mode
```sh
xrandr --newmode "1368x1000_60.00"  113.00  1368 1448 1592 1816  1000 1003 1013 1038 -hsync +vsync

```

With our new mode added we now add the mode to our open output. First lets choose a disconnected output from the output of 
```sh
xrandr

```
Should look something like this:
```sh
Screen 0: minimum 320 x 200, current 5760 x 3160, maximum 16384 x 16384
DisplayPort-0 disconnected (normal left inverted right x axis y axis)
DisplayPort-1 connected primary 3840x2160+1920+0 (normal left inverted right x axis y axis) 600mm x 340mm
   720x480       60.00*+  59.94  
   640x480       60.00    59.94  

```
Add the mode to the output you want, here I use DisplayPort-0
```sh
xrandr --addmode DisplayPort-0 1368x1000_60.00

```

With the new mode added to the output, you can now actually output that virtual monitor. This command puts it below my other monitor, but you can set it on any side.
```sh
xrandr --output DisplayPort-0 --mode 1368x1000_60.00 --below DisplayPort-1

```

And bam, now you have a Virtual Monitor setup.

Now open up Weylus, and follow the qr code on your ipad to connect.

You can now see your new virtual monitor on your ipad. If you want to get the most out of your ipad screen I recommend opening the Weylus link in Safari, and adding the page to your Ipad home page, this way you do not have any tabs taking up your valuable screen real estate.



## Setting up TabletTools

You can work without these, but you will have more limits, TabletTools is designed to be a simple customizable hotkey toolbar for using linux on an Ipad.

Some things you may realize at first that there is no way to right click with the current setup, or in blender there is no way to hold down "Alt" or Shift" which are required for basic movement around the viewport.
This is what TabletTools solves.

Currently there are Toggle Switches for Alt and Shift, as well as buttons for right click and undo. Likely more features on the way, I only concieved the app yesterday..

For TabletTools setup refer to the [README in the TabletTools repo](https://github.com/0xStabby/TabletTools#prerequisites)



How to use Blender on Linux through an IPad

Feed:

Why Test-Driven Development is important for writing secure smart contracts

New features added to chatgpt-vim

Writing secure smart contract code with solidity

ChatGPT helped me make a ChatGPT Vim plugin.

Using Blender, on Linux, through an IPad